Come iniziare a utilizzare BouncyCastle?

Question

Quindi, dopo il CodingHorror's fun with encryption e i commenti thrash, stiamo riconsiderando la nostra crittografia.

In questo caso, è necessario passare alcune informazioni che identificano un utente a un servizio di terze parti che quindi richiamerà un servizio sul nostro sito Web con le informazioni più un hash.

Il secondo servizio cerca informazioni su quell'utente e poi lo restituisce al servizio di terze parti.

Vogliamo crittografare queste informazioni utente che entrano nel servizio di terze parti e decrittografarlo dopo che è uscito. Quindi non è una crittografia longeva.

Nell'articolo horror di codifica, Coda Hale ha consigliato BouncyCastle e un'astrazione di alto livello nella libreria per eseguire la crittografia specifica per una particolare esigenza.

Il mio problema è che gli spazi dei nomi di BouncyCastle sono enormi e la documentazione è inesistente. Qualcuno può indicarmi questa libreria di astrazione di alto livello? (Oppure un'altra opzione oltre a BouncyCastle?)

Answer 1

Astrazione di alto livello? Suppongo che le più alte astrazioni di livello nella libreria Bouncy Castle dovrebbe includere:

• Il BlockCipher di interfaccia (per un algoritmo simmetrico)
• La classe BufferedBlockCipher
• Il AsymmetricBlockCipher interfaccia
• Il BufferedAsymmetricBlockCipher classe
• Il Interfaccia CipherParameters (per l'inizializzazione dei codici a blocchi e dei codici a blocchi asimmetrici)

Sono principalmente familiare con la versione Java della libreria. Forse questo frammento di codice vi offrirà un'astrazione abbastanza alto per i vostri scopi (ad esempio utilizza la crittografia AES-256):

public byte[] encryptAES256(byte[] input, byte[] key) throws InvalidCipherTextException { 
    assert key.length == 32; // 32 bytes == 256 bits 
    CipherParameters cipherParameters = new KeyParameter(key); 

    /* 
    * A full list of BlockCiphers can be found at http://www.bouncycastle.org/docs/docs1.6/org/bouncycastle/crypto/BlockCipher.html 
    */ 
    BlockCipher blockCipher = new AESEngine(); 

    /* 
    * Paddings available (http://www.bouncycastle.org/docs/docs1.6/org/bouncycastle/crypto/paddings/BlockCipherPadding.html): 
    * - ISO10126d2Padding 
    * - ISO7816d4Padding 
    * - PKCS7Padding 
    * - TBCPadding 
    * - X923Padding 
    * - ZeroBytePadding 
    */ 
    BlockCipherPadding blockCipherPadding = new ZeroBytePadding(); 

    BufferedBlockCipher bufferedBlockCipher = new PaddedBufferedBlockCipher(blockCipher, blockCipherPadding); 

    return encrypt(input, bufferedBlockCipher, cipherParameters); 
} 

public byte[] encrypt(byte[] input, BufferedBlockCipher bufferedBlockCipher, CipherParameters cipherParameters) throws InvalidCipherTextException { 
    boolean forEncryption = true; 
    return process(input, bufferedBlockCipher, cipherParameters, forEncryption); 
} 

public byte[] decrypt(byte[] input, BufferedBlockCipher bufferedBlockCipher, CipherParameters cipherParameters) throws InvalidCipherTextException { 
    boolean forEncryption = false; 
    return process(input, bufferedBlockCipher, cipherParameters, forEncryption); 
} 

public byte[] process(byte[] input, BufferedBlockCipher bufferedBlockCipher, CipherParameters cipherParameters, boolean forEncryption) throws InvalidCipherTextException { 
    bufferedBlockCipher.init(forEncryption, cipherParameters); 

    int inputOffset = 0; 
    int inputLength = input.length; 

    int maximumOutputLength = bufferedBlockCipher.getOutputSize(inputLength); 
    byte[] output = new byte[maximumOutputLength]; 
    int outputOffset = 0; 
    int outputLength = 0; 

    int bytesProcessed; 

    bytesProcessed = bufferedBlockCipher.processBytes(
      input, inputOffset, inputLength, 
      output, outputOffset 
     ); 
    outputOffset += bytesProcessed; 
    outputLength += bytesProcessed; 

    bytesProcessed = bufferedBlockCipher.doFinal(output, outputOffset); 
    outputOffset += bytesProcessed; 
    outputLength += bytesProcessed; 

    if (outputLength == output.length) { 
     return output; 
    } else { 
     byte[] truncatedOutput = new byte[outputLength]; 
     System.arraycopy(
       output, 0, 
       truncatedOutput, 0, 
       outputLength 
      ); 
     return truncatedOutput; 
    } 
} 

Edit: Ops, ho appena letto l'articolo si è collegato al. Sembra che parli di astrazioni di livello ancora più elevato di quanto pensassi (ad esempio, "invia un messaggio confidenziale"). Temo di non capire bene a cosa stia andando.

Answer 2

Supponendo di scrivere l'applicazione in Java, si consiglia di non utilizzare un provider specifico, ma di sviluppare l'applicazione su JCE di Sun (Java Cryptography Extension). Ciò può renderti indipendente da qualsiasi fornitore sottostante, ad esempio, puoi cambiare facilmente i provider finché usi cifrari ampiamente implementati. Ti dà un certo livello di astrazione in quanto non devi conoscere tutti i dettagli delle implementazioni e potresti proteggerti un po 'dall'usare le classi sbagliate (ad es. Usando la crittografia grezza senza padding adeguato ecc.) Inoltre, Sun fornisce una discreta quantità di documentazione e esempi di codice.

Answer 3

JCE non funzionerà per me perché vogliamo una potenza di 256 bit e non possiamo modificare la configurazione java sul sistema per consentirglielo. Peccato che il castello gonfiabile non abbia un'API di alto livello come JCE.

"Nota che bouncycastle è costituito da due librerie, la libreria di crittografia leggera e la libreria di interfaccia del fornitore JCE.Le restrizioni di keysize vengono applicate dal livello JCE, ma non è necessario utilizzare questo livello.Se si utilizza l'API Crypto leggero direttamente non si dispone di alcuna restrizione, non importa quale file politica sono o non sono installati." http://www.coderanch.com/t/420255/Security/AES-cryptoPerms-Unlimited-Cryptography

Answer 4

Il libro contiene Beginning Cryptography with Java molto utili esempi e spiegazioni basate sulla libreria bouncycastle

Answer 5

realtà ho scoperto che questo campione utilizza la crittografia a 128 bit di default al posto di 256 bit ho fatto un piccolo cambiamento:.

BlockCipher blockCipher = new AESEngine(); 

diventa ora:

BlockCipher blockCipher = new RijndaelEngine(256); 

e funziona insieme con la mia applicazione client di crittografia AES a 256 C++

Answer 6

Un esempio di un alto (er) API-level in BouncyCastle sarebbe la (Cryptographic Message Syntax) pacchetto di CMS. Questo viene fornito in un vaso separato (bcmail) dal provider stesso, e viene scritto sul JCE (la versione C# è scritta rispetto all'API leggera).

"Invia un messaggio confidenziale" è implementato, in parole povere, dalla classe CMSEnvelopedDataGenerator e tutto ciò che è necessario fare è fornire il messaggio, scegliere un algoritmo di crittografia (tutti i dettagli gestiti internamente), quindi specificare uno o più modi in cui un destinatario sarà in grado di leggere il messaggio: questo può essere basato su una chiave pubblica/certificato, un segreto condiviso, una password o persino un protocollo di chiave d'accordo. Puoi avere più di un destinatario su un messaggio e puoi combinare tipi di destinatario.

È possibile utilizzare CMSSignedDataGenerator per inviare un messaggio verificabile allo stesso modo. Se si desidera firmare e crittografare, le strutture CMS sono nidificabili/componibili (ma l'ordine potrebbe essere importante). C'è anche CMSCompressedDataGenerator e recentemente aggiunto CMSAuthenticatedData.

Answer 7

È possibile utilizzare:

byte[] process(bool encrypt, byte[] input, byte[] key) 
{ 
    var cipher = CipherUtilities.GetCipher("Blowfish"); 
    cipher.Init(false, new KeyParameter(key)); 
    return cipher.DoFinal(input); 
} 

// Encrypt: 
byte[] encrypted = process(true, clear, key); 

// Decrypt: 
byte[] decrypted = process(false, encrypted, key); 

See: https://github.com/wernight/decrypt-toolbox/blob/master/dtDecrypt/Program.cs