ECDSA Android vérifier avec la clé publique toujours retourner faux

Question

J'ai un certain jeton et je dois d'abord le signer avec SHA256 et ECDSA basé sur la clé privée et publique de KeyStore.

Chaque fois que j'essaie de vérifier la valeur, je deviens faux. Je ne sais pas pourquoi.

Est-ce que quelqu'un a une idée pour résoudre ce problème?

Voici mes fonctions pour générer et charger des clés:

private void generateKeys(){ 

    try { 

     keyStore = KeyStore.getInstance(KEYSTORE_NAME); 
     keyStore.load(null); 

     if(!keyStore.containsAlias(KEY_NAME)) { 
      KeyPairGenerator keyPairGenerator = KeyPairGenerator.getInstance(KeyProperties.KEY_ALGORITHM_EC, KEYSTORE_NAME); 
      keyPairGenerator.initialize(
        new KeyGenParameterSpec.Builder(KEY_NAME, 
          KeyProperties.PURPOSE_SIGN | KeyProperties.PURPOSE_VERIFY) 
          .setDigests(KeyProperties.DIGEST_SHA256, 
            KeyProperties.DIGEST_SHA512) 
          .setAlgorithmParameterSpec(new ECGenParameterSpec("secp256r1")) 
          .setUserAuthenticationRequired(false) 
          .build()); 
      keyPairGenerator.generateKeyPair(); 

      setRegistred(true); 
     } 
    } catch (NoSuchAlgorithmException e) { 
     e.printStackTrace(); 
    } catch (NoSuchProviderException e) { 
     e.printStackTrace(); 
    } catch (InvalidAlgorithmParameterException e) { 
     e.printStackTrace(); 
    } catch (CertificateException e) { 
     e.printStackTrace(); 
    } catch (KeyStoreException e) { 
     e.printStackTrace(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
} 



private void loadKeys(){ 
    try { 
     keyStore = KeyStore.getInstance(KEYSTORE_NAME); 
     keyStore.load(null); 
     if(keyStore.containsAlias(KEY_NAME)) { 
      publicKey = keyStore.getCertificate(KEY_NAME).getPublicKey(); 
      privateKey = (PrivateKey) keyStore.getKey(KEY_NAME, null); 
     } 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } catch (NoSuchAlgorithmException e) { 
     e.printStackTrace(); 
    } catch (CertificateException e) { 
     e.printStackTrace(); 
    } catch (KeyStoreException e) { 
     e.printStackTrace(); 
    } catch (UnrecoverableKeyException e) { 
     e.printStackTrace(); 
    } 
} 

Voici comment la valeur de signe:

public String sign(String inputStr, FingerprintManager.CryptoObject cryptoObject){ 
    try { 
     Signature signature = Signature.getInstance(SecurityConstants.SIGNATURE); 
     signature.initSign(privateKey); 
     signature.update(inputStr.getBytes()); 
     byte[] signedBytes = signature.sign(); 
     String result = Base64.encodeToString(signedBytes, Base64.DEFAULT); 
     Log.d("TAG", result); 
     return result; 
    } catch (SignatureException e) { 
     e.printStackTrace(); 
    } catch (InvalidKeyException e) { 
     e.printStackTrace(); 
    } catch (NoSuchAlgorithmException e) { 
     e.printStackTrace(); 
    } 
    return null; 
} 

Voici mon essai de vérifier avec la clé publique:

public boolean verifyWithPublicKey(String input, FingerprintManager.CryptoObject cryptoObject){ 
    try { 
     Signature signature = Signature.getInstance(SecurityConstants.SIGNATURE); 
     keyStore = KeyStore.getInstance(KEYSTORE_NAME); 
     keyStore.load(null); 
     PublicKey pk = getPublicKeyForVerification(); 
     signature.initVerify(pk); 
     signature.update(input.getBytes()); 
     boolean isVerifed = signature.verify(input.getBytes()); 
     Log.d("TAG", String.valueOf(isVerifed)); 
     return isVerifed; 
    } catch (SignatureException e) { 
     e.printStackTrace(); 
    } catch (InvalidKeyException e) { 
     e.printStackTrace(); 
    } catch (CertificateException e) { 
     e.printStackTrace(); 
    } catch (NoSuchAlgorithmException e) { 
     e.printStackTrace(); 
    } catch (KeyStoreException e) { 
     e.printStackTrace(); 
    } catch (IOException e) { 
     e.printStackTrace(); 
    } 
    return false; 
} 

Answer 1

L'erreur est ici, lorsque vous écrivez le code suivant pour vérifier la signature:

signature.update(input.getBytes()); 
boolean isVerifed = signature.verify(input.getBytes()); 

Avec ce code, vous essayez de vérifier que la signature a été signée avec elle-même!

Vous devriez avoir:

signature.update(MY_BYTES_ARRAY_OF_DATA); 
boolean isVerifed = signature.verify(MY_SIGNATURE); 

Ne pas oublier que la signature n'encapsule pas les données signées par défaut.

Si vous voulez avoir un format qui comprend des données signées et signature associée, l'utilisation S/MIME, OpenPGP, etc.