自学教程：C++ CRYPTO_gcm128_setiv函数代码示例

static intaes_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,    const unsigned char *iv, int enc){	EVP_AES_GCM_CTX *gctx = ctx->cipher_data;	if (!iv && !key)		return 1;	if (key) {		gctx->ctr = aes_gcm_set_key(&gctx->ks, &gctx->gcm,		    key, ctx->key_len);		/* If we have an iv can set it directly, otherwise use		 * saved IV.		 */		if (iv == NULL && gctx->iv_set)			iv = gctx->iv;		if (iv) {			CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);			gctx->iv_set = 1;		}		gctx->key_set = 1;	} else {		/* If key set use IV, otherwise copy */		if (gctx->key_set)			CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);		else			memcpy(gctx->iv, iv, gctx->ivlen);		gctx->iv_set = 1;		gctx->iv_gen = 0;	}	return 1;}

static int aesni_gcm_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,                              const uint8_t *iv, int enc) {  EVP_AES_GCM_CTX *gctx = ctx->cipher_data;  if (!iv && !key) {    return 1;  }  if (key) {    aesni_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks.ks);    CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks, (block128_f)aesni_encrypt);    gctx->ctr = (ctr128_f)aesni_ctr32_encrypt_blocks;    /* If we have an iv can set it directly, otherwise use     * saved IV. */    if (iv == NULL && gctx->iv_set) {      iv = gctx->iv;    }    if (iv) {      CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);      gctx->iv_set = 1;    }    gctx->key_set = 1;  } else {    /* If key set use IV, otherwise copy */    if (gctx->key_set) {      CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);    } else {      memcpy(gctx->iv, iv, gctx->ivlen);    }    gctx->iv_set = 1;    gctx->iv_gen = 0;  }  return 1;}

static int aes_gcm_init_key(EVP_CIPHER_CTX *ctx, const uint8_t *key,                            const uint8_t *iv, int enc) {  EVP_AES_GCM_CTX *gctx = ctx->cipher_data;  if (!iv && !key) {    return 1;  }  if (key) {    OPENSSL_memset(&gctx->gcm, 0, sizeof(gctx->gcm));    gctx->ctr = aes_ctr_set_key(&gctx->ks.ks, &gctx->gcm.gcm_key, NULL, key,                                ctx->key_len);    // If we have an iv can set it directly, otherwise use saved IV.    if (iv == NULL && gctx->iv_set) {      iv = gctx->iv;    }    if (iv) {      CRYPTO_gcm128_setiv(&gctx->gcm, &gctx->ks.ks, iv, gctx->ivlen);      gctx->iv_set = 1;    }    gctx->key_set = 1;  } else {    // If key set use IV, otherwise copy    if (gctx->key_set) {      CRYPTO_gcm128_setiv(&gctx->gcm, &gctx->ks.ks, iv, gctx->ivlen);    } else {      OPENSSL_memcpy(gctx->iv, iv, gctx->ivlen);    }    gctx->iv_set = 1;    gctx->iv_gen = 0;  }  return 1;}

static int aes_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,                            const unsigned char *iv, int enc){    EVP_AES_GCM_CTX *gctx = ctx->cipher_data;    if (!iv && !key)        return 1;    if (key) {        do {#  ifdef BSAES_CAPABLE            if (BSAES_CAPABLE) {                AES_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks);                CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,                                   (block128_f) AES_encrypt);                gctx->ctr = (ctr128_f) bsaes_ctr32_encrypt_blocks;                break;            } else#  endif#  ifdef VPAES_CAPABLE            if (VPAES_CAPABLE) {                vpaes_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks);                CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,                                   (block128_f) vpaes_encrypt);                gctx->ctr = NULL;                break;            } else#  endif                (void)0;        /* terminate potentially open 'else' */            AES_set_encrypt_key(key, ctx->key_len * 8, &gctx->ks);            CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,                               (block128_f) AES_encrypt);#  ifdef AES_CTR_ASM            gctx->ctr = (ctr128_f) AES_ctr32_encrypt;#  else            gctx->ctr = NULL;#  endif        } while (0);        /*         * If we have an iv can set it directly, otherwise use saved IV.         */        if (iv == NULL && gctx->iv_set)            iv = gctx->iv;        if (iv) {            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);            gctx->iv_set = 1;        }        gctx->key_set = 1;    } else {        /* If key set use IV, otherwise copy */        if (gctx->key_set)            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);        else            memcpy(gctx->iv, iv, gctx->ivlen);        gctx->iv_set = 1;        gctx->iv_gen = 0;    }    return 1;}

static int test_gcm128(int idx){    unsigned char out[512];    SIZED_DATA K = gcm128_vectors[idx].K;    SIZED_DATA IV = gcm128_vectors[idx].IV;    SIZED_DATA A = gcm128_vectors[idx].A;    SIZED_DATA P = gcm128_vectors[idx].P;    SIZED_DATA C = gcm128_vectors[idx].C;    SIZED_DATA T = gcm128_vectors[idx].T;    GCM128_CONTEXT ctx;    AES_KEY key;    /* Size 1 inputs are special-cased to signal NULL. */    if (A.size == 1)        A.data = NULL;    if (P.size == 1)        P.data = NULL;    if (C.size == 1)        C.data = NULL;    AES_set_encrypt_key(K.data, K.size * 8, &key);    CRYPTO_gcm128_init(&ctx, &key, (block128_f)AES_encrypt);    CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);    memset(out, 0, P.size);    if (A.data != NULL)        CRYPTO_gcm128_aad(&ctx, A.data, A.size);    if (P.data != NULL)        CRYPTO_gcm128_encrypt( &ctx, P.data, out, P.size);    if (!TEST_false(CRYPTO_gcm128_finish(&ctx, T.data, 16))            || (C.data != NULL                    && !TEST_mem_eq(out, P.size, C.data, P.size)))        return 0;    CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);    memset(out, 0, P.size);    if (A.data != NULL)        CRYPTO_gcm128_aad(&ctx, A.data, A.size);    if (C.data != NULL)        CRYPTO_gcm128_decrypt(&ctx, C.data, out, P.size);    if (!TEST_false(CRYPTO_gcm128_finish(&ctx, T.data, 16))            || (P.data != NULL                    && !TEST_mem_eq(out, P.size, P.data, P.size)))        return 0;    return 1;}

static int aead_aes_gcm_open(const EVP_AEAD_CTX *ctx, uint8_t *out,                             size_t *out_len, size_t max_out_len,                             const uint8_t *nonce, size_t nonce_len,                             const uint8_t *in, size_t in_len,                             const uint8_t *ad, size_t ad_len) {  size_t bulk = 0;  const struct aead_aes_gcm_ctx *gcm_ctx = ctx->aead_state;  uint8_t tag[EVP_AEAD_AES_GCM_TAG_LEN];  size_t plaintext_len;  GCM128_CONTEXT gcm;  if (in_len < gcm_ctx->tag_len) {    OPENSSL_PUT_ERROR(CIPHER, aead_aes_gcm_open, CIPHER_R_BAD_DECRYPT);    return 0;  }  plaintext_len = in_len - gcm_ctx->tag_len;  if (max_out_len < plaintext_len) {    OPENSSL_PUT_ERROR(CIPHER, aead_aes_gcm_open, CIPHER_R_BUFFER_TOO_SMALL);    return 0;  }  memcpy(&gcm, &gcm_ctx->gcm, sizeof(gcm));  CRYPTO_gcm128_setiv(&gcm, nonce, nonce_len);  if (!CRYPTO_gcm128_aad(&gcm, ad, ad_len)) {    return 0;  }  if (gcm_ctx->ctr) {    if (!CRYPTO_gcm128_decrypt_ctr32(&gcm, in + bulk, out + bulk,                                     in_len - bulk - gcm_ctx->tag_len,                                     gcm_ctx->ctr)) {      return 0;    }  } else {    if (!CRYPTO_gcm128_decrypt(&gcm, in + bulk, out + bulk,                               in_len - bulk - gcm_ctx->tag_len)) {      return 0;    }  }  CRYPTO_gcm128_tag(&gcm, tag, gcm_ctx->tag_len);  if (CRYPTO_memcmp(tag, in + plaintext_len, gcm_ctx->tag_len) != 0) {    OPENSSL_PUT_ERROR(CIPHER, aead_aes_gcm_open, CIPHER_R_BAD_DECRYPT);    return 0;  }  *out_len = plaintext_len;  return 1;}

static void benchmark_gcm128(const unsigned char *K, size_t Klen,                             const unsigned char *IV, size_t IVlen){#ifdef OPENSSL_CPUID_OBJ    GCM128_CONTEXT ctx;    AES_KEY key;    uint32_t start, gcm_t, ctr_t;    union {        u64 u;        u8 c[1024];    } buf;    AES_set_encrypt_key(K, Klen * 8, &key);    CRYPTO_gcm128_init(&ctx, &key, (block128_f) AES_encrypt);    CRYPTO_gcm128_setiv(&ctx, IV, IVlen);    CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));    start = OPENSSL_rdtsc();    CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));    gcm_t = OPENSSL_rdtsc() - start;    CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),                          &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,                          (block128_f) AES_encrypt);    start = OPENSSL_rdtsc();    CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),                          &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,                          (block128_f) AES_encrypt);    ctr_t = OPENSSL_rdtsc() - start;    printf("%.2f-%.2f=%.2f/n",           gcm_t / (double)sizeof(buf),           ctr_t / (double)sizeof(buf),           (gcm_t - ctr_t) / (double)sizeof(buf));# ifdef GHASH    {        void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],                             const u8 *inp, size_t len) = ctx.ghash;        GHASH((&ctx), buf.c, sizeof(buf));        start = OPENSSL_rdtsc();        for (i = 0; i < 100; ++i)            GHASH((&ctx), buf.c, sizeof(buf));        gcm_t = OPENSSL_rdtsc() - start;        printf("%.2f/n", gcm_t / (double)sizeof(buf) / (double)i);    }# endif#else    fprintf(stderr,            "Benchmarking of modes isn't available on this platform/n");#endif}

static int aria_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,                                 const unsigned char *iv, int enc){    int ret;    EVP_ARIA_GCM_CTX *gctx = EVP_C_DATA(EVP_ARIA_GCM_CTX,ctx);    if (!iv && !key)        return 1;    if (key) {        ret = aria_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,                                   &gctx->ks.ks);        CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,                           (block128_f) aria_encrypt);        if (ret < 0) {            EVPerr(EVP_F_ARIA_GCM_INIT_KEY,EVP_R_ARIA_KEY_SETUP_FAILED);            return 0;        }        /*         * If we have an iv can set it directly, otherwise use saved IV.         */        if (iv == NULL && gctx->iv_set)            iv = gctx->iv;        if (iv) {            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);            gctx->iv_set = 1;        }        gctx->key_set = 1;    } else {        /* If key set use IV, otherwise copy */        if (gctx->key_set)            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);        else            memcpy(gctx->iv, iv, gctx->ivlen);        gctx->iv_set = 1;        gctx->iv_gen = 0;    }    return 1;}

static intaead_aes_gcm_open(const EVP_AEAD_CTX *ctx, unsigned char *out, size_t *out_len,    size_t max_out_len, const unsigned char *nonce, size_t nonce_len,    const unsigned char *in, size_t in_len, const unsigned char *ad,    size_t ad_len){	const struct aead_aes_gcm_ctx *gcm_ctx = ctx->aead_state;	unsigned char tag[EVP_AEAD_AES_GCM_TAG_LEN];	GCM128_CONTEXT gcm;	size_t plaintext_len;	size_t bulk = 0;	if (in_len < gcm_ctx->tag_len) {		EVPerr(EVP_F_AEAD_AES_GCM_OPEN, EVP_R_BAD_DECRYPT);		return 0;	}	plaintext_len = in_len - gcm_ctx->tag_len;	if (max_out_len < plaintext_len) {		EVPerr(EVP_F_AEAD_AES_GCM_OPEN, EVP_R_BUFFER_TOO_SMALL);		return 0;	}	memcpy(&gcm, &gcm_ctx->gcm, sizeof(gcm));	CRYPTO_gcm128_setiv(&gcm, nonce, nonce_len);	if (CRYPTO_gcm128_aad(&gcm, ad, ad_len))		return 0;	if (gcm_ctx->ctr) {		if (CRYPTO_gcm128_decrypt_ctr32(&gcm, in + bulk, out + bulk,		    in_len - bulk - gcm_ctx->tag_len, gcm_ctx->ctr))			return 0;	} else {		if (CRYPTO_gcm128_decrypt(&gcm, in + bulk, out + bulk,		    in_len - bulk - gcm_ctx->tag_len))			return 0;	}	CRYPTO_gcm128_tag(&gcm, tag, gcm_ctx->tag_len);	if (CRYPTO_memcmp(tag, in + plaintext_len, gcm_ctx->tag_len) != 0) {		EVPerr(EVP_F_AEAD_AES_GCM_OPEN, EVP_R_BAD_DECRYPT);		return 0;	}	*out_len = plaintext_len;	return 1;}

static int sms4_gcm_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,                             const unsigned char *iv, int enc){    EVP_SMS4_GCM_CTX *gctx = EVP_C_DATA(EVP_SMS4_GCM_CTX,ctx);    if (!iv && !key)        return 1;    if (key) {        do {            (void)0;        /* terminate potentially open 'else' */            sms4_set_encrypt_key(&gctx->ks.ks, key);            CRYPTO_gcm128_init(&gctx->gcm, &gctx->ks,                               (block128_f)sms4_encrypt);            gctx->ctr = NULL;        } while (0);        /*         * If we have an iv can set it directly, otherwise use saved IV.         */        if (iv == NULL && gctx->iv_set)            iv = gctx->iv;        if (iv) {            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);            gctx->iv_set = 1;        }        gctx->key_set = 1;    } else {        /* If key set use IV, otherwise copy */        if (gctx->key_set)            CRYPTO_gcm128_setiv(&gctx->gcm, iv, gctx->ivlen);        else            memcpy(gctx->iv, iv, gctx->ivlen);        gctx->iv_set = 1;        gctx->iv_gen = 0;    }    return 1;}

static int aead_aes_gcm_open_gather(const EVP_AEAD_CTX *ctx, uint8_t *out,                                    const uint8_t *nonce, size_t nonce_len,                                    const uint8_t *in, size_t in_len,                                    const uint8_t *in_tag, size_t in_tag_len,                                    const uint8_t *ad, size_t ad_len) {  const struct aead_aes_gcm_ctx *gcm_ctx = ctx->aead_state;  uint8_t tag[EVP_AEAD_AES_GCM_TAG_LEN];  if (nonce_len == 0) {    OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_NONCE_SIZE);    return 0;  }  if (in_tag_len != ctx->tag_len) {    OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BAD_DECRYPT);    return 0;  }  const AES_KEY *key = &gcm_ctx->ks.ks;  GCM128_CONTEXT gcm;  OPENSSL_memset(&gcm, 0, sizeof(gcm));  OPENSSL_memcpy(&gcm.gcm_key, &gcm_ctx->gcm_key, sizeof(gcm.gcm_key));  CRYPTO_gcm128_setiv(&gcm, key, nonce, nonce_len);  if (!CRYPTO_gcm128_aad(&gcm, ad, ad_len)) {    return 0;  }  if (gcm_ctx->ctr) {    if (!CRYPTO_gcm128_decrypt_ctr32(&gcm, key, in, out, in_len,                                     gcm_ctx->ctr)) {      return 0;    }  } else {    if (!CRYPTO_gcm128_decrypt(&gcm, key, in, out, in_len)) {      return 0;    }  }  CRYPTO_gcm128_tag(&gcm, tag, ctx->tag_len);  if (CRYPTO_memcmp(tag, in_tag, ctx->tag_len) != 0) {    OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BAD_DECRYPT);    return 0;  }  return 1;}

static int aead_aes_gcm_seal(const EVP_AEAD_CTX *ctx, uint8_t *out,                             size_t *out_len, size_t max_out_len,                             const uint8_t *nonce, size_t nonce_len,                             const uint8_t *in, size_t in_len,                             const uint8_t *ad, size_t ad_len) {  size_t bulk = 0;  const struct aead_aes_gcm_ctx *gcm_ctx = ctx->aead_state;  GCM128_CONTEXT gcm;  if (in_len + gcm_ctx->tag_len < in_len) {    OPENSSL_PUT_ERROR(CIPHER, aead_aes_gcm_seal, CIPHER_R_TOO_LARGE);    return 0;  }  if (max_out_len < in_len + gcm_ctx->tag_len) {    OPENSSL_PUT_ERROR(CIPHER, aead_aes_gcm_seal, CIPHER_R_BUFFER_TOO_SMALL);    return 0;  }  memcpy(&gcm, &gcm_ctx->gcm, sizeof(gcm));  CRYPTO_gcm128_setiv(&gcm, nonce, nonce_len);  if (ad_len > 0 && !CRYPTO_gcm128_aad(&gcm, ad, ad_len)) {    return 0;  }  if (gcm_ctx->ctr) {    if (!CRYPTO_gcm128_encrypt_ctr32(&gcm, in + bulk, out + bulk, in_len - bulk,                                     gcm_ctx->ctr)) {      return 0;    }  } else {    if (!CRYPTO_gcm128_encrypt(&gcm, in + bulk, out + bulk, in_len - bulk)) {      return 0;    }  }  CRYPTO_gcm128_tag(&gcm, out + in_len, gcm_ctx->tag_len);  *out_len = in_len + gcm_ctx->tag_len;  return 1;}

static intaead_aes_gcm_seal(const EVP_AEAD_CTX *ctx, unsigned char *out, size_t *out_len,    size_t max_out_len, const unsigned char *nonce, size_t nonce_len,    const unsigned char *in, size_t in_len, const unsigned char *ad,    size_t ad_len){	const struct aead_aes_gcm_ctx *gcm_ctx = ctx->aead_state;	GCM128_CONTEXT gcm;	size_t bulk = 0;	if (max_out_len < in_len + gcm_ctx->tag_len) {		EVPerr(EVP_F_AEAD_AES_GCM_SEAL, EVP_R_BUFFER_TOO_SMALL);		return 0;	}	memcpy(&gcm, &gcm_ctx->gcm, sizeof(gcm));	CRYPTO_gcm128_setiv(&gcm, nonce, nonce_len);	if (ad_len > 0 && CRYPTO_gcm128_aad(&gcm, ad, ad_len))		return 0;	if (gcm_ctx->ctr) {		if (CRYPTO_gcm128_encrypt_ctr32(&gcm, in + bulk, out + bulk,		    in_len - bulk, gcm_ctx->ctr))			return 0;	} else {		if (CRYPTO_gcm128_encrypt(&gcm, in + bulk, out + bulk,		    in_len - bulk))			return 0;	}	CRYPTO_gcm128_tag(&gcm, out + in_len, gcm_ctx->tag_len);	*out_len = in_len + gcm_ctx->tag_len;	return 1;}

static int aead_aes_gcm_seal_scatter(const EVP_AEAD_CTX *ctx, uint8_t *out,                                     uint8_t *out_tag, size_t *out_tag_len,                                     size_t max_out_tag_len,                                     const uint8_t *nonce, size_t nonce_len,                                     const uint8_t *in, size_t in_len,                                     const uint8_t *extra_in,                                     size_t extra_in_len,                                     const uint8_t *ad, size_t ad_len) {  const struct aead_aes_gcm_ctx *gcm_ctx = ctx->aead_state;  if (extra_in_len + ctx->tag_len < ctx->tag_len) {    OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_TOO_LARGE);    return 0;  }  if (max_out_tag_len < extra_in_len + ctx->tag_len) {    OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_BUFFER_TOO_SMALL);    return 0;  }  if (nonce_len == 0) {    OPENSSL_PUT_ERROR(CIPHER, CIPHER_R_INVALID_NONCE_SIZE);    return 0;  }  const AES_KEY *key = &gcm_ctx->ks.ks;  GCM128_CONTEXT gcm;  OPENSSL_memset(&gcm, 0, sizeof(gcm));  OPENSSL_memcpy(&gcm.gcm_key, &gcm_ctx->gcm_key, sizeof(gcm.gcm_key));  CRYPTO_gcm128_setiv(&gcm, key, nonce, nonce_len);  if (ad_len > 0 && !CRYPTO_gcm128_aad(&gcm, ad, ad_len)) {    return 0;  }  if (gcm_ctx->ctr) {    if (!CRYPTO_gcm128_encrypt_ctr32(&gcm, key, in, out, in_len,                                     gcm_ctx->ctr)) {      return 0;    }  } else {    if (!CRYPTO_gcm128_encrypt(&gcm, key, in, out, in_len)) {      return 0;    }  }  if (extra_in_len) {    if (gcm_ctx->ctr) {      if (!CRYPTO_gcm128_encrypt_ctr32(&gcm, key, extra_in, out_tag,                                       extra_in_len, gcm_ctx->ctr)) {        return 0;      }    } else {      if (!CRYPTO_gcm128_encrypt(&gcm, key, extra_in, out_tag, extra_in_len)) {        return 0;      }    }  }  CRYPTO_gcm128_tag(&gcm, out_tag + extra_in_len, ctx->tag_len);  *out_tag_len = ctx->tag_len + extra_in_len;  return 1;}

static int aes_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr) {  EVP_AES_GCM_CTX *gctx = c->cipher_data;  switch (type) {    case EVP_CTRL_INIT:      gctx->key_set = 0;      gctx->iv_set = 0;      gctx->ivlen = c->cipher->iv_len;      gctx->iv = c->iv;      gctx->taglen = -1;      gctx->iv_gen = 0;      return 1;    case EVP_CTRL_AEAD_SET_IVLEN:      if (arg <= 0) {        return 0;      }      // Allocate memory for IV if needed      if (arg > EVP_MAX_IV_LENGTH && arg > gctx->ivlen) {        if (gctx->iv != c->iv) {          OPENSSL_free(gctx->iv);        }        gctx->iv = OPENSSL_malloc(arg);        if (!gctx->iv) {          return 0;        }      }      gctx->ivlen = arg;      return 1;    case EVP_CTRL_AEAD_SET_TAG:      if (arg <= 0 || arg > 16 || c->encrypt) {        return 0;      }      OPENSSL_memcpy(c->buf, ptr, arg);      gctx->taglen = arg;      return 1;    case EVP_CTRL_AEAD_GET_TAG:      if (arg <= 0 || arg > 16 || !c->encrypt || gctx->taglen < 0) {        return 0;      }      OPENSSL_memcpy(ptr, c->buf, arg);      return 1;    case EVP_CTRL_AEAD_SET_IV_FIXED:      // Special case: -1 length restores whole IV      if (arg == -1) {        OPENSSL_memcpy(gctx->iv, ptr, gctx->ivlen);        gctx->iv_gen = 1;        return 1;      }      // Fixed field must be at least 4 bytes and invocation field      // at least 8.      if (arg < 4 || (gctx->ivlen - arg) < 8) {        return 0;      }      if (arg) {        OPENSSL_memcpy(gctx->iv, ptr, arg);      }      if (c->encrypt && !RAND_bytes(gctx->iv + arg, gctx->ivlen - arg)) {        return 0;      }      gctx->iv_gen = 1;      return 1;    case EVP_CTRL_GCM_IV_GEN:      if (gctx->iv_gen == 0 || gctx->key_set == 0) {        return 0;      }      CRYPTO_gcm128_setiv(&gctx->gcm, &gctx->ks.ks, gctx->iv, gctx->ivlen);      if (arg <= 0 || arg > gctx->ivlen) {        arg = gctx->ivlen;      }      OPENSSL_memcpy(ptr, gctx->iv + gctx->ivlen - arg, arg);      // Invocation field will be at least 8 bytes in size and      // so no need to check wrap around or increment more than      // last 8 bytes.      ctr64_inc(gctx->iv + gctx->ivlen - 8);      gctx->iv_set = 1;      return 1;    case EVP_CTRL_GCM_SET_IV_INV:      if (gctx->iv_gen == 0 || gctx->key_set == 0 || c->encrypt) {        return 0;      }      OPENSSL_memcpy(gctx->iv + gctx->ivlen - arg, ptr, arg);      CRYPTO_gcm128_setiv(&gctx->gcm, &gctx->ks.ks, gctx->iv, gctx->ivlen);      gctx->iv_set = 1;      return 1;    case EVP_CTRL_COPY: {      EVP_CIPHER_CTX *out = ptr;      EVP_AES_GCM_CTX *gctx_out = out->cipher_data;      if (gctx->iv == c->iv) {        gctx_out->iv = out->iv;      } else {        gctx_out->iv = OPENSSL_malloc(gctx->ivlen);        if (!gctx_out->iv) {          return 0;//.........这里部分代码省略.........

static int32_t create_format_v1(unsigned char *wire,				loc_t *loc,				struct crypt_inode_info *info,				struct master_cipher_info *master){	int32_t ret;	struct mtd_format_v1 *fmt;	unsigned char mtd_key[16];	AES_KEY EMTD_KEY;	unsigned char nmtd_link_key[16];	uint32_t ad;	GCM128_CONTEXT *gctx;	fmt = (struct mtd_format_v1 *)wire;	fmt->minor_id = info->nr_minor;	fmt->alg_id = AES_CIPHER_ALG;	fmt->dkey_factor = master->m_dkey_size >> KEY_FACTOR_BITS;	fmt->block_bits = master->m_block_bits;	fmt->mode_id = master->m_mode;	/*	 * retrieve keys for the parts of metadata	 */	ret = get_emtd_file_key(info, master, mtd_key);	if (ret)		return ret;	ret = get_nmtd_link_key(loc, master, nmtd_link_key);	if (ret)		return ret;		AES_set_encrypt_key(mtd_key, sizeof(mtd_key)*8, &EMTD_KEY);	gctx = CRYPTO_gcm128_new(&EMTD_KEY, (block128_f)AES_encrypt);	/* TBD: Check return values */	CRYPTO_gcm128_setiv(gctx, info->oid, sizeof(uuid_t));	ad = htole32(MTD_LOADER_V1);	ret = CRYPTO_gcm128_aad(gctx, (const unsigned char *)&ad, sizeof(ad));	if (ret) {		gf_log("crypt", GF_LOG_ERROR, " CRYPTO_gcm128_aad failed");		CRYPTO_gcm128_release(gctx);		return ret;	}	ret = CRYPTO_gcm128_encrypt(gctx,				    get_EMTD_V1(fmt),				    get_EMTD_V1(fmt),				    SIZE_OF_EMTD_V1);	if (ret) {		gf_log("crypt", GF_LOG_ERROR, " CRYPTO_gcm128_encrypt failed");		CRYPTO_gcm128_release(gctx);		return ret;	}	/*	 * set MAC of encrypted part of metadata	 */	CRYPTO_gcm128_tag(gctx, get_EMTD_V1_MAC(fmt), SIZE_OF_EMTD_V1_MAC);	CRYPTO_gcm128_release(gctx);	/*	 * set the first MAC of non-encrypted part of metadata 	 */	return create_link_mac_v1(fmt, 0, loc, info, master);}

static int sms4_gcm_ctrl(EVP_CIPHER_CTX *c, int type, int arg, void *ptr){    EVP_SMS4_GCM_CTX *gctx = EVP_C_DATA(EVP_SMS4_GCM_CTX,c);    switch (type) {    case EVP_CTRL_INIT:        gctx->key_set = 0;        gctx->iv_set = 0;        gctx->ivlen = EVP_CIPHER_CTX_iv_length(c);        gctx->iv = EVP_CIPHER_CTX_iv_noconst(c);        gctx->taglen = -1;        gctx->iv_gen = 0;        gctx->tls_aad_len = -1;        return 1;    case EVP_CTRL_AEAD_SET_IVLEN:        if (arg <= 0)            return 0;        /* Allocate memory for IV if needed */        if ((arg > EVP_MAX_IV_LENGTH) && (arg > gctx->ivlen)) {            if (gctx->iv != EVP_CIPHER_CTX_iv_noconst(c))                OPENSSL_free(gctx->iv);            gctx->iv = OPENSSL_malloc(arg);            if (gctx->iv == NULL)                return 0;        }        gctx->ivlen = arg;        return 1;    case EVP_CTRL_AEAD_SET_TAG:        if (arg <= 0 || arg > 16 || EVP_CIPHER_CTX_encrypting(c))            return 0;        memcpy(EVP_CIPHER_CTX_buf_noconst(c), ptr, arg);        gctx->taglen = arg;        return 1;    case EVP_CTRL_AEAD_GET_TAG:        if (arg <= 0 || arg > 16 || !EVP_CIPHER_CTX_encrypting(c)            || gctx->taglen < 0)            return 0;        memcpy(ptr, EVP_CIPHER_CTX_buf_noconst(c), arg);        return 1;    case EVP_CTRL_GCM_SET_IV_FIXED:        /* Special case: -1 length restores whole IV */        if (arg == -1) {            memcpy(gctx->iv, ptr, gctx->ivlen);            gctx->iv_gen = 1;            return 1;        }        /*         * Fixed field must be at least 4 bytes and invocation field at least         * 8.         */        if ((arg < 4) || (gctx->ivlen - arg) < 8)            return 0;        if (arg)            memcpy(gctx->iv, ptr, arg);        if (EVP_CIPHER_CTX_encrypting(c)            && RAND_bytes(gctx->iv + arg, gctx->ivlen - arg) <= 0)            return 0;        gctx->iv_gen = 1;        return 1;    case EVP_CTRL_GCM_IV_GEN:        if (gctx->iv_gen == 0 || gctx->key_set == 0)            return 0;        CRYPTO_gcm128_setiv(&gctx->gcm, gctx->iv, gctx->ivlen);        if (arg <= 0 || arg > gctx->ivlen)            arg = gctx->ivlen;        memcpy(ptr, gctx->iv + gctx->ivlen - arg, arg);        /*         * Invocation field will be at least 8 bytes in size and so no need         * to check wrap around or increment more than last 8 bytes.         */        ctr64_inc(gctx->iv + gctx->ivlen - 8);        gctx->iv_set = 1;        return 1;    case EVP_CTRL_GCM_SET_IV_INV:        if (gctx->iv_gen == 0 || gctx->key_set == 0            || EVP_CIPHER_CTX_encrypting(c))            return 0;        memcpy(gctx->iv + gctx->ivlen - arg, ptr, arg);        CRYPTO_gcm128_setiv(&gctx->gcm, gctx->iv, gctx->ivlen);        gctx->iv_set = 1;        return 1;    case EVP_CTRL_AEAD_TLS1_AAD:        /* Save the AAD for later use */        if (arg != EVP_AEAD_TLS1_AAD_LEN)            return 0;        memcpy(EVP_CIPHER_CTX_buf_noconst(c), ptr, arg);        gctx->tls_aad_len = arg;        {            unsigned int len =                EVP_CIPHER_CTX_buf_noconst(c)[arg - 2] << 8                | EVP_CIPHER_CTX_buf_noconst(c)[arg - 1];            /* Correct length for explicit IV */            len -= EVP_GCM_TLS_EXPLICIT_IV_LEN;            /* If decrypting correct for tag too *///.........这里部分代码省略.........

static int run_test_case(unsigned test_num, const struct test_case *test) {  size_t key_len, plaintext_len, additional_data_len, nonce_len, ciphertext_len,      tag_len;  uint8_t *key = NULL, *plaintext = NULL, *additional_data = NULL,          *nonce = NULL, *ciphertext = NULL, *tag = NULL, *out = NULL;  int ret = 0;  AES_KEY aes_key;  GCM128_CONTEXT ctx;  if (!decode_hex(&key, &key_len, test->key, test_num, "key") ||      !decode_hex(&plaintext, &plaintext_len, test->plaintext, test_num,                  "plaintext") ||      !decode_hex(&additional_data, &additional_data_len, test->additional_data,                  test_num, "additional_data") ||      !decode_hex(&nonce, &nonce_len, test->nonce, test_num, "nonce") ||      !decode_hex(&ciphertext, &ciphertext_len, test->ciphertext, test_num,                  "ciphertext") ||      !decode_hex(&tag, &tag_len, test->tag, test_num, "tag")) {    goto out;  }  if (plaintext_len != ciphertext_len) {    fprintf(stderr, "%u: plaintext and ciphertext have differing lengths./n",            test_num);    goto out;  }  if (key_len != 16 && key_len != 24 && key_len != 32) {    fprintf(stderr, "%u: bad key length./n", test_num);    goto out;  }  if (tag_len != 16) {    fprintf(stderr, "%u: bad tag length./n", test_num);    goto out;  }  out = OPENSSL_malloc(plaintext_len);  if (AES_set_encrypt_key(key, key_len*8, &aes_key)) {    fprintf(stderr, "%u: AES_set_encrypt_key failed./n", test_num);    goto out;  }  CRYPTO_gcm128_init(&ctx, &aes_key, (block128_f) AES_encrypt);  CRYPTO_gcm128_setiv(&ctx, nonce, nonce_len);  memset(out, 0, plaintext_len);  if (additional_data) {    CRYPTO_gcm128_aad(&ctx, additional_data, additional_data_len);  }  if (plaintext) {    CRYPTO_gcm128_encrypt(&ctx, plaintext, out, plaintext_len);  }  if (!CRYPTO_gcm128_finish(&ctx, tag, tag_len) ||      (ciphertext && memcmp(out, ciphertext, plaintext_len) != 0)) {    fprintf(stderr, "%u: encrypt failed./n", test_num);    hexdump("got ", out, plaintext_len);    hexdump("want", ciphertext, plaintext_len);    goto out;  }  CRYPTO_gcm128_setiv(&ctx, nonce, nonce_len);  memset(out, 0, plaintext_len);  if (additional_data) {    CRYPTO_gcm128_aad(&ctx, additional_data, additional_data_len);  }  if (ciphertext) {    CRYPTO_gcm128_decrypt(&ctx, ciphertext, out, plaintext_len);  }  if (!CRYPTO_gcm128_finish(&ctx, tag, tag_len)) {    fprintf(stderr, "%u: decrypt failed./n", test_num);    goto out;  }  if (plaintext && memcmp(out, plaintext, plaintext_len)) {    fprintf(stderr, "%u: plaintext doesn't match./n", test_num);    goto out;  }  ret = 1;out:  OPENSSL_free(key);  OPENSSL_free(plaintext);  OPENSSL_free(additional_data);  OPENSSL_free(nonce);  OPENSSL_free(ciphertext);  OPENSSL_free(tag);  OPENSSL_free(out);  return ret;}