ObjectivePGP Téléchargement - ObjectivePGP Téléchargement du code source

ObjectivePGP

Autre code source

1.0

Télécharger

objectifpgp

ObjectivePGP est une implémentation du protocole OpenPGP pour iOS et MacOS. OpenPGP est la norme de chiffrement des e-mails la plus utilisée. Il est défini par le groupe de travail OpenPGP de l'Internet Engineering Task Force (IETF).

Voici l'histoire du blog.

Comment m'impliquer?

Vous voulez aider, super! Allez-y et fournissez notre dépôt, apportez vos modifications et envoyez-nous une demande de traction.

Contribution

Vous êtes invités à contribuer. Voir contribution.md
Veuillez créer une demande de traction.

La licence

L'objectifpgp reste sous une double licence:

GRATUIT pour une utilisation non commerciale, couvert par la variante de la licence BSD. Cela signifie que vous devez mentionner Marcin Krzyżanowski en tant qu'auteur original de ce code et reproduire le texte de licence dans votre application.
Licence d'utilisation commerciale à utiliser dans les produits commerciaux. Veuillez garder à l'esprit que certains produits gratuits restent des produits commerciaux. Veuillez me contacter par e-mail pour plus de détails.

Vous ne savez pas quoi choisir? Vérifier la FAQ

Installation

Swift Package Manager

 dependencies: [
    .package(url: "https://github.com/krzyzanowskim/ObjectivePGP.git", .upToNextMinor(from: "0.99.4"))
]

Cocoapodes

 pod 'ObjectivePGP'

Frameworks

ObjectivePGP est livré avec les frameworks de la dernière version, vous pouvez copier et intégrer votre projet:

Objectivepgp.framework
Objectivepgp.xcframework

Usage

Objectif-c

# import < ObjectivePGP/ObjectivePGP.h >

Rapide

import ObjectivePGP

Lire les clés (privé ou publique)

 NSArray <PGPKey *> *keys = [ObjectivePGP readKeysFromPath: @" /path/to/key.asc " error: nil ];

 let keys = try ObjectivePGP . readKeys ( fromPath : " /path/to/key.asc " )

Clés

Le clés est un stockage (en mémoire ou sur disque) qui conserve toutes sortes de clés PGP.

PGPKeyring *keyring = ObjectivePGP.defaultKeyring;
PGPKeyring *keyring = [[PGPKeyring alloc ] init ];

NSArray <PGPKey *> *allKeys = keyring.keys;
[keyring importKeys: @[key]];
[keyring deleteKeys: @[key]];

[keyring importKey: @" 979E4B03DFFE30C6 " fromPath: @" /path/to/secring.gpg " ];
PGPKey *key = [keyring findKeyWithIdentifier: @" 979E4B03DFFE30C6 " ];
NSArray <PGPKey *> keys = [pgp findKeysForUserID: @" Name <[email protected]> " ];

 let keyring = ObjectivePGP . defaultKeyring
let keyring = Keyring ( )

let allKeys = keyring . keys
keyring . import ( keys : [ key ] )
keyring . delete ( keys : [ key ] )

keyring . import ( keyIdentifier : " 979E4B03DFFE30C6 " , fromPath : " /path/to/secring.gpg " )
if let key = keyring . findKey ( " 979E4B03DFFE30C6 " ) {
	// key found in keyring
}

keyring . findKeys ( " Name <[email protected]> " ) . forEach ( key ) {
	// process key
}

Clés d'exportation (privés ou publics)

 // Write keyring to file
[[keyring export: error] writeToURL: [ NSURL fileURLWithString: @" keyring.gpg " ]];

// Public keys data
NSData *publicKeys = [keyring exportKeysOfType: PGPKeyTypePublic error: nil ];

// Write keyring to file
try keyring . export ( ) . write ( to : URL ( fileURLWithPath : " keyring.gpg " ) )

// Public keys (Data)
let publicKeys = keyring . exportKeys ( of : . public )

Signer et vérifier les données (ou le fichier)

Signez une donnée avec une clé:

 NSData *signature = [ObjectivePGP sign: fileContent detached: YES usingKeys: @[key] passphraseForKey: nil error: nil ];
[ObjectivePGP verify: fileContent withSignature: signature usingKeys: @[key] passphraseForKey: nil error: nil ];

 let signature = try ObjectivePGP . sign ( encryptedBin , detached : true , using : [ key1 ] )
try ObjectivePGP . verify ( encryptedBin , withSignature : signature , using : [ key1 ] )

Crypter et décrypter

 NSData *encrypted = [ObjectivePGP encrypt :fileContent addSignature: YES usingKeys: @[key] passphraseForKey: nil error: nil ];
[ObjectivePGP decrypt: encrypted andVerifySignature: YES usingKeys: @[key] passphraseForKey: nil error: nil ];

 let encrypted = try ObjectivePGP . encrypt ( fileContent ) , addSignature : true , using : [ key1 , key2 ] )
let decrypted = try ObjectivePGP . decrypt ( encrypted , andVerifySignature : true , using : [ key1 ] )

Générer une nouvelle paire de clés

PGPKeyGenerator *generator = [[PGPKeyGenerator alloc ] init ];
PGPKey *key = [generator generateFor: @" Marcin <[email protected]> " passphrase: nil ];
NSData *publicKeyData = [key export: PGPKeyTypePublic error: nil ];
NSData *secretKeyData = [key export: PGPKeyTypeSecret error: nil ];

 let key = KeyGenerator ( ) . generate ( for : " [email protected] " , passphrase : " password " )
let publicKey = try key . export ( keyType : . public )
let secretKey = try key . export ( keyType : . secret )

Armure ASCII

L'armure ASCII est un convertisseur de codage binaire à textuel. L'armure ASCII implique le retrait de la messagerie cryptée dans ASCII afin qu'ils puissent être envoyés dans un format de messagerie standard tel que le courrier électronique.

Exemple:

 -----BEGIN PGP PUBLIC KEY BLOCK-----
Comment: For more info see https://www.objectivepgp.org

[...]
-----END PGP PUBLIC KEY BLOCK-----

La classe PGPArmor peut être utilisée pour convertir le format binaire en format ASCII

 NSString *armoredKey = [PGPArmor armoredData: encrypted as: PGPArmorPublicKey];

 let armoredKey = Armor . armored ( Data ( ) , as : . publicKey )

Lorsque vous convertissez manuellement, il est important d'utiliser la bonne valeur PGPArmorType qui définit l'en-tête. C'est peut-être une partie délicate alors voici la feuille de triche:

Tapez des données	PgParmorType	Exemple
Crypté	`PGPArmorMessage`	`Armor.armored(ObjectivePGP.encrypt(...), as: .message)`
Décrypté	`PGPArmorMessage`	`Armor.armored(ObjectivePGP.decrypt(...), as: .message)`
Clé publique	`PGPArmorTypePublic`	`Armor.armored(key.export(), as: .publicKey)`
Clé secrète	`PGPArmorTypeSecret`	`Armor.armored(key.export(), as: .secretKey)`