Weak Encryption: Inadequate RSA Padding

A criptografia RSA de chave pública é executada sem usar preenchimento OAEP, o que torna a criptografia fraca.

Na prática, a criptografia com uma chave pública RSA é geralmente combinada com um esquema de preenchimento. Um esquema de preenchimento pode impedir ataques ao RSA que só funcionam quando a criptografia é executada sem preenchimento.

Exemplo 1: O código a seguir executa a criptografia usando uma chave pública RSA sem usar um esquema de preenchimento:

  static public byte[] EncryptWithRSA(byte[] plaintext, RSAParameters key) {
    try {
      RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
      rsa.ImportParameters(key);
      return rsa.Encrypt(plaintext, false);
    }
    catch(CryptographicException e) {
      Console.WriteLine(e.Message);
      return null;
    }
  }

A criptografia RSA de chave pública é executada sem usar preenchimento OAEP, o que torna a criptografia fraca.

Na prática, a criptografia com uma chave pública RSA é geralmente combinada com um esquema de preenchimento. Um esquema de preenchimento pode impedir ataques ao RSA que só funcionam quando a criptografia é executada sem preenchimento.

Exemplo 1: O código a seguir executa a criptografia usando uma chave pública RSA sem usar um esquema de preenchimento:

  void encrypt_with_rsa(BIGNUM *out, BIGNUM *in, RSA *key) {
    u_char *inbuf, *outbuf;
    int ilen;
    ...
    ilen = BN_num_bytes(in);
    inbuf = xmalloc(ilen);
    BN_bn2bin(in, inbuf);
    if ((len = RSA_public_encrypt(ilen, inbuf, outbuf, key, RSA_NO_PADDING)) <= 0) {
      fatal("encrypt_with_rsa() failed");
    }
    ...
  }

A criptografia RSA de chave pública é executada sem usar preenchimento OAEP, o que torna a criptografia fraca.

Na prática, a criptografia com uma chave pública RSA é geralmente combinada com um esquema de preenchimento. Um esquema de preenchimento pode impedir ataques ao RSA que só funcionam quando a criptografia é executada sem preenchimento.

Exemplo 1: O código a seguir realiza a criptografia usando uma chave pública RSA com o esquema de preenchimento PKCS#1 v1.5:

...
import "crypto/rsa"
...
plaintext := []byte("Attack at dawn")
cipherText, err := rsa.EncryptPKCS1v15(rand.Reader, &k.PublicKey, plaintext)
...

A criptografia RSA de chave pública é executada sem usar preenchimento OAEP, o que torna a criptografia fraca.

Na prática, a criptografia com uma chave pública RSA é geralmente combinada com um esquema de preenchimento. Um esquema de preenchimento pode impedir ataques ao RSA que só funcionam quando a criptografia é executada sem preenchimento.

Exemplo 1: O código a seguir executa a criptografia usando uma chave pública RSA sem usar um esquema de preenchimento:

+ (NSData *) encryptData:(NSData *) plaintextData withKey:(SecKeyRef *) publicKey {
    CFErrorRef error = nil;
    
    NSData *ciphertextData = (NSData*) CFBridgingRelease(
        SecKeyCreateEncryptedData(*publicKey,
                                  kSecKeyAlgorithmRSAEncryptionPKCS1,
                                  (__bridge CFDataRef) plaintextData,
                                  &error));
    
    if (error) {
        // handle error ...
    }
    
    return ciphertextData;
}

A criptografia RSA de chave pública é executada sem usar preenchimento OAEP, o que torna a criptografia fraca.

Na prática, a criptografia com uma chave pública RSA é geralmente combinada com um esquema de preenchimento. Um esquema de preenchimento pode impedir ataques ao RSA que só funcionam quando a criptografia é executada sem preenchimento.

Exemplo 1: O código a seguir executa a criptografia usando uma chave pública RSA sem usar um esquema de preenchimento:

  function encrypt($input, $key) {
    $output='';
    openssl_public_encrypt($input, $output, $key, OPENSSL_NO_PADDING);
    return $output;
  }

A criptografia RSA de chave pública é executada sem usar preenchimento OAEP, o que torna a criptografia fraca.

Na prática, a criptografia com uma chave pública RSA é geralmente combinada com um esquema de preenchimento. Um esquema de preenchimento pode impedir ataques ao RSA que só funcionam quando a criptografia é executada sem preenchimento.

Exemplo 1: O código a seguir executa a criptografia usando uma chave pública RSA sem usar um esquema de preenchimento:

...
from Crypto.PublicKey import RSA

message = 'Attack at dawn'
key = RSA.importKey(open('pubkey.der').read())
ciphertext = key.encrypt(message)
...

A criptografia RSA de chave pública é executada sem usar preenchimento OAEP, o que torna a criptografia fraca.

Na prática, a criptografia com uma chave pública RSA é geralmente combinada com um esquema de preenchimento. Um esquema de preenchimento pode impedir ataques ao RSA que só funcionam quando a criptografia é executada sem preenchimento.

Exemplo 1: O código a seguir executa a criptografia usando uma chave pública RSA sem usar um esquema de preenchimento:

require 'openssl'
...
key = OpenSSL::PKey::RSA.new 2048
public_encrypted = key.public_encrypt(data) #padding type not specified
...

No Example 1OpenSSL::PKey::RSA#public_encrypt só é chamado com uma string, e não especifica o tipo de preenchimento a ser usado. O preenchimento usa como padrão OpenSSL::PKey::RSA::PKCS1_PADDING.

A criptografia RSA de chave pública é executada sem usar preenchimento OAEP, o que torna a criptografia fraca.

Na prática, a criptografia com uma chave pública RSA é geralmente combinada com um esquema de preenchimento. Um esquema de preenchimento pode impedir ataques ao RSA que só funcionam quando a criptografia é executada sem preenchimento.

Exemplo 1: O código a seguir executa a criptografia usando uma chave pública RSA sem usar um esquema de preenchimento:

func encrypt(data plaintextData:Data, publicKey:SecKey) throws -> Data {
    var error: Unmanaged<CFError>?
    guard let ciphertextData = SecKeyCreateEncryptedData(publicKey,
                                                         .rsaEncryptionPKCS1,
                                                         plaintextData as CFData,
                                                         &error) else {
        throw error!.takeRetainedValue() as Error
    }
    return ciphertextData as Data;
}