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

static HWND findMDIParentOf (HWND w){    const int frameThickness = GetSystemMetrics (SM_CYFIXEDFRAME);    while (w != 0)    {        HWND parent = GetParent (w);        if (parent == 0)            break;        TCHAR windowType [32];        zeromem (windowType, sizeof (windowType));        GetClassName (parent, windowType, 31);        if (String (windowType).equalsIgnoreCase (T("MDIClient")))        {            w = parent;            break;        }        RECT windowPos;        GetWindowRect (w, &windowPos);        RECT parentPos;        GetWindowRect (parent, &parentPos);        int dw = (parentPos.right - parentPos.left) - (windowPos.right - windowPos.left);        int dh = (parentPos.bottom - parentPos.top) - (windowPos.bottom - windowPos.top);        if (dw > 100 || dh > 100)            break;        w = parent;        if (dw == 2 * frameThickness)            break;    }    return w;}

/**   Hash data from an open file handle.    @param hash   The index of the hash you want to use  @param in     The FILE* handle of the file you want to hash  @param out    [out] The destination of the digest  @param outlen [in/out] The max size and resulting size of the digest  @result CRYPT_OK if successful   */int hash_filehandle(int hash, FILE *in, unsigned char *out, unsigned long *outlen){#ifdef LTC_NO_FILE    return CRYPT_NOP;#else    hash_state md;    unsigned char buf[512];    size_t x;    int err;    LTC_ARGCHK(out    != NULL);    LTC_ARGCHK(outlen != NULL);    LTC_ARGCHK(in     != NULL);    if ((err = hash_is_valid(hash)) != CRYPT_OK) {        return err;    }    if (*outlen < hash_descriptor[hash].hashsize) {       *outlen = hash_descriptor[hash].hashsize;       return CRYPT_BUFFER_OVERFLOW;    }    if ((err = hash_descriptor[hash].init(&md)) != CRYPT_OK) {       return err;    }    *outlen = hash_descriptor[hash].hashsize;    do {        x = fread(buf, 1, sizeof(buf), in);        if ((err = hash_descriptor[hash].process(&md, buf, x)) != CRYPT_OK) {           return err;        }    } while (x == sizeof(buf));    err = hash_descriptor[hash].done(&md, out);#ifdef LTC_CLEAN_STACK    zeromem(buf, sizeof(buf));#endif    return err;#endif}

/**   EAX encrypt and produce an authentication tag   @param cipher     The index of the cipher desired   @param key        The secret key to use   @param keylen     The length of the secret key (octets)   @param nonce      The session nonce [use once]   @param noncelen   The length of the nonce   @param header     The header for the session   @param headerlen  The length of the header (octets)   @param pt         The plaintext   @param ptlen      The length of the plaintext (octets)   @param ct         [out] The ciphertext   @param tag        [out] The destination tag   @param taglen     [in/out] The max size and resulting size of the authentication tag   @return CRYPT_OK if successful*/int eax_encrypt_authenticate_memory(int cipher,    const unsigned char *key,    unsigned long keylen,    const unsigned char *nonce,  unsigned long noncelen,    const unsigned char *header, unsigned long headerlen,    const unsigned char *pt,     unsigned long ptlen,          unsigned char *ct,          unsigned char *tag,    unsigned long *taglen){   int err;   eax_state *eax;   LTC_ARGCHK(key    != NULL);   LTC_ARGCHK(pt     != NULL);   LTC_ARGCHK(ct     != NULL);   LTC_ARGCHK(tag    != NULL);   LTC_ARGCHK(taglen != NULL);   eax = XMALLOC(sizeof(*eax));   if ((err = eax_init(eax, cipher, key, keylen, nonce, noncelen, header, headerlen)) != CRYPT_OK) {      goto LBL_ERR;    }   if ((err = eax_encrypt(eax, pt, ct, ptlen)) != CRYPT_OK) {      goto LBL_ERR;    }    if ((err = eax_done(eax, tag, taglen)) != CRYPT_OK) {      goto LBL_ERR;    }   err = CRYPT_OK;LBL_ERR:#ifdef LTC_CLEAN_STACK   zeromem(eax, sizeof(*eax));#endif   XFREE(eax);   return err;   }

/**   HMAC a block of memory to produce the authentication tag   @param hash      The index of the hash to use    @param key       The secret key    @param keylen    The length of the secret key (octets)   @param in        The data to HMAC   @param inlen     The length of the data to HMAC (octets)   @param out       [out] Destination of the authentication tag   @param outlen    [in/out] Max size and resulting size of authentication tag   @return CRYPT_OK if successful*/int hmac_memory(int hash,                 const unsigned char *key,  unsigned long keylen,                const unsigned char *in,   unsigned long inlen,                       unsigned char *out,  unsigned long *outlen){    hmac_state *hmac;    int err;    LTC_ARGCHK(key    != NULL);    LTC_ARGCHK(in   != NULL);    LTC_ARGCHK(out    != NULL);     LTC_ARGCHK(outlen != NULL);    /* allocate ram for hmac state */    hmac = XMALLOC(sizeof(hmac_state));    if (hmac == NULL) {       return CRYPT_MEM;    }    if ((err = hmac_init(hmac, hash, key, keylen)) != CRYPT_OK) {       goto LBL_ERR;    }    if ((err = hmac_process(hmac, in, inlen)) != CRYPT_OK) {       goto LBL_ERR;    }    if ((err = hmac_done(hmac, out, outlen)) != CRYPT_OK) {       goto LBL_ERR;    }   err = CRYPT_OK;LBL_ERR:#ifdef LTC_CLEAN_STACK   zeromem(hmac, sizeof(hmac_state));#endif   XFREE(hmac);   return err;   }

int Compression::compress(uint8_t *p_dst, const uint8_t *p_src, int p_src_size,Mode p_mode) {	switch(p_mode) {		case MODE_FASTLZ: {			if (p_src_size<16) {				uint8_t src[16];				zeromem(&src[p_src_size],16-p_src_size);				copymem(src,p_src,p_src_size);				return fastlz_compress(src,16,p_dst);			} else {				return fastlz_compress(p_src,p_src_size,p_dst);			}		} break;		case MODE_DEFLATE: {			z_stream strm;			strm.zalloc = zipio_alloc;			strm.zfree = zipio_free;			strm.opaque = Z_NULL;			int err = deflateInit(&strm,Z_DEFAULT_COMPRESSION);			if (err!=Z_OK)			    return -1;			strm.avail_in=p_src_size;			int aout = deflateBound(&strm,p_src_size);;			strm.avail_out=aout;			strm.next_in=(Bytef*)p_src;			strm.next_out=p_dst;			deflate(&strm,Z_FINISH);			aout = aout - strm.avail_out;			deflateEnd(&strm);			return aout;		} break;	}	ERR_FAIL_V(-1);}

/**  Hash a block of memory and store the digest.  @param hash   The index of the hash you wish to use  @param in     The data you wish to hash  @param inlen  The length of the data to hash (octets)  @param out    [out] Where to store the digest  @param outlen [in/out] Max size and resulting size of the digest  @return CRYPT_OK if successful*/int hash_memory(int hash, const unsigned char *in, unsigned long inlen, unsigned char *out, unsigned long *outlen){    hash_state *md;    int err;    LTC_ARGCHK(in     != NULL);    LTC_ARGCHK(out    != NULL);    LTC_ARGCHK(outlen != NULL);    if ((err = hash_is_valid(hash)) != CRYPT_OK) {        return err;    }    if (*outlen < hash_descriptor[hash].hashsize) {       *outlen = hash_descriptor[hash].hashsize;       return CRYPT_BUFFER_OVERFLOW;    }    md = XMALLOC(sizeof(hash_state));    if (md == NULL) {       return CRYPT_MEM;    }    if ((err = hash_descriptor[hash].init(md)) != CRYPT_OK) {       goto LBL_ERR;    }    if ((err = hash_descriptor[hash].process(md, in, inlen)) != CRYPT_OK) {       goto LBL_ERR;    }    err = hash_descriptor[hash].done(md, out);    *outlen = hash_descriptor[hash].hashsize;LBL_ERR:#ifdef LTC_CLEAN_STACK    zeromem(md, sizeof(hash_state));#endif    XFREE(md);    return err;}

int rng_make_prng(int bits, int wprng, prng_state *prng,                   void (*callback)(void)){   unsigned char buf[256];   int err;      _ARGCHK(prng != NULL);   /* check parameter */   if ((err = prng_is_valid(wprng)) != CRYPT_OK) {      return err;   }   if (bits < 64 || bits > 1024) {      return CRYPT_INVALID_PRNGSIZE;   }   if ((err = prng_descriptor[wprng].start(prng)) != CRYPT_OK) {      return err;   }   bits = ((bits/8)+((bits&7)!=0?1:0)) * 2;   if (rng_get_bytes(buf, (unsigned long)bits, callback) != (unsigned long)bits) {      return CRYPT_ERROR_READPRNG;   }   if ((err = prng_descriptor[wprng].add_entropy(buf, (unsigned long)bits, prng)) != CRYPT_OK) {      return err;   }   if ((err = prng_descriptor[wprng].ready(prng)) != CRYPT_OK) {      return err;   }   #ifdef CLEAN_STACK      zeromem(buf, sizeof(buf));   #endif   return CRYPT_OK;}

/**   OMAC a block of memory    @param cipher    The index of the desired cipher   @param key       The secret key   @param keylen    The length of the secret key (octets)   @param in        The data to send through OMAC   @param inlen     The length of the data to send through OMAC (octets)   @param out       [out] The destination of the authentication tag   @param outlen    [in/out]  The max size and resulting size of the authentication tag (octets)   @return CRYPT_OK if successful*/int omac_memory(int cipher,                 const unsigned char *key, unsigned long keylen,                const unsigned char *in,  unsigned long inlen,                      unsigned char *out, unsigned long *outlen){   int err;   omac_state *omac;   LTC_ARGCHK(key    != NULL);   LTC_ARGCHK(in     != NULL);   LTC_ARGCHK(out    != NULL);   LTC_ARGCHK(outlen != NULL);   /* allocate ram for omac state */   omac = XMALLOC(sizeof(omac_state));   if (omac == NULL) {      return CRYPT_MEM;   }   /* omac process the message */   if ((err = omac_init(omac, cipher, key, keylen)) != CRYPT_OK) {      goto LBL_ERR;   }   if ((err = omac_process(omac, in, inlen)) != CRYPT_OK) {      goto LBL_ERR;   }   if ((err = omac_done(omac, out, outlen)) != CRYPT_OK) {      goto LBL_ERR;   }   err = CRYPT_OK;LBL_ERR:#ifdef LTC_CLEAN_STACK   zeromem(omac, sizeof(omac_state));#endif   XFREE(omac);   return err;   }

//==============================================================================MidiOutFilter::MidiOutFilter(){    programs = new JuceProgram[getNumPrograms()];    devices = MidiOutput::getDevices();    midiOutput = 0;	loadDefaultFxb();    curProgram=0;    init=true;    setCurrentProgram (0);    samplesToNextClock=0;    samplesToNextMTC=0;    wasPlaying=false;    startAt=-999.0;    startMTCAt=-999.0;    sendclock=false;    sendmtc=false;    mtcNumber=0;    zeromem (&lastPosInfo, sizeof (lastPosInfo));}

void DemoJuceFilter::setSyncToHost (bool t){	if (t != isSyncedToHost)	{		zeromem (&lastPosInfo, sizeof (lastPosInfo));		lastPosInfo.timeSigNumerator = 4;		lastPosInfo.timeSigDenominator = 4;		lastPosInfo.bpm = 120;		sendChangeMessage (this);	}		if (!t)	{		syncThread->setBPM (intBpm);		syncThread->startThread();	}	else	{		syncThread->signalThreadShouldExit();	}	isSyncedToHost = t;}

/**  Process an entire GCM packet in one call.  @param key               The secret key  @param keylen            The length of the secret key  @param iv                The initialization vector  @param ivlen             The length of the initialization vector  @param aad               The additional authentication data (header)  @param aadlen            The length of the aad  @param in                The plaintext  @param inlen             The length of the plaintext (ciphertext length is the same)  @param out               The ciphertext  @param tag               [out] The MAC tag  @param taglen            [in/out] The MAC tag length  @param direction         Encrypt or Decrypt mode (CHCHA20POLY1305_ENCRYPT or CHCHA20POLY1305_DECRYPT)  @return CRYPT_OK on success */int chacha20poly1305_memory(const unsigned char *key, unsigned long keylen,                            const unsigned char *iv,  unsigned long ivlen,                            const unsigned char *aad, unsigned long aadlen,                            const unsigned char *in,  unsigned long inlen,                                  unsigned char *out,                                  unsigned char *tag, unsigned long *taglen,                            int direction){   chacha20poly1305_state st;   int err;   LTC_ARGCHK(key != NULL);   LTC_ARGCHK(iv  != NULL);   LTC_ARGCHK(in  != NULL);   LTC_ARGCHK(out != NULL);   LTC_ARGCHK(tag != NULL);   if ((err = chacha20poly1305_init(&st, key, keylen)) != CRYPT_OK)          { goto LBL_ERR; }   if ((err = chacha20poly1305_setiv(&st, iv, ivlen)) != CRYPT_OK)           { goto LBL_ERR; }   if (aad && aadlen > 0) {      if ((err = chacha20poly1305_add_aad(&st, aad, aadlen)) != CRYPT_OK)    { goto LBL_ERR; }   }   if (direction == CHCHA20POLY1305_ENCRYPT) {      if ((err = chacha20poly1305_encrypt(&st, in, inlen, out)) != CRYPT_OK) { goto LBL_ERR; }   }   else if (direction == CHCHA20POLY1305_DECRYPT) {      if ((err = chacha20poly1305_decrypt(&st, in, inlen, out)) != CRYPT_OK) { goto LBL_ERR; }   }   else {      err = CRYPT_INVALID_ARG;      goto LBL_ERR;   }   err = chacha20poly1305_done(&st, tag, taglen);LBL_ERR:#ifdef LTC_CLEAN_STACK   zeromem(&st, sizeof(chacha20poly1305_state));#endif   return err;}

void AudioProcessorPlayer::audioDeviceAboutToStart (AudioIODevice* device){    const ScopedLock sl (lock);    sampleRate = device->getCurrentSampleRate();    blockSize = device->getCurrentBufferSizeSamples();    numInputChans = device->getActiveInputChannels().countNumberOfSetBits();    numOutputChans = device->getActiveOutputChannels().countNumberOfSetBits();    messageCollector.reset (sampleRate);    zeromem (channels, sizeof (channels));    if (processor != nullptr)    {        if (isPrepared)            processor->releaseResources();        AudioProcessor* const oldProcessor = processor;        setProcessor (nullptr);        setProcessor (oldProcessor);    }}

/******************************************************************************* * Given a secure payload entrypoint info pointer, entry point PC, register * width, cpu id & pointer to a context data structure, this function will * initialize tsp context and entry point info for the secure payload ******************************************************************************/void tspd_init_tsp_ep_state(struct entry_point_info *tsp_entry_point,				uint32_t rw,				uint64_t pc,				tsp_context_t *tsp_ctx){	uint32_t ep_attr;	/* Passing a NULL context is a critical programming error */	assert(tsp_ctx);	assert(tsp_entry_point);	assert(pc);	/*	 * We support AArch64 TSP for now.	 * TODO: Add support for AArch32 TSP	 */	assert(rw == TSP_AARCH64);	/* Associate this context with the cpu specified */	tsp_ctx->mpidr = read_mpidr_el1();	tsp_ctx->state = 0;	set_tsp_pstate(tsp_ctx->state, TSP_PSTATE_OFF);	clr_yield_smc_active_flag(tsp_ctx->state);	cm_set_context(&tsp_ctx->cpu_ctx, SECURE);	/* initialise an entrypoint to set up the CPU context */	ep_attr = SECURE | EP_ST_ENABLE;	if (read_sctlr_el3() & SCTLR_EE_BIT)		ep_attr |= EP_EE_BIG;	SET_PARAM_HEAD(tsp_entry_point, PARAM_EP, VERSION_1, ep_attr);	tsp_entry_point->pc = pc;	tsp_entry_point->spsr = SPSR_64(MODE_EL1,					MODE_SP_ELX,					DISABLE_ALL_EXCEPTIONS);	zeromem(&tsp_entry_point->args, sizeof(tsp_entry_point->args));}

/**  Create a DSA shared secret between two keys  @param private_key      The private DSA key (the exponent)  @param base             The base of the exponentiation (allows this to be used for both encrypt and decrypt)   @param public_key       The public key  @param out              [out] Destination of the shared secret  @param outlen           [in/out] The max size and resulting size of the shared secret  @return CRYPT_OK if successful*/int dsa_shared_secret(void          *private_key, void *base,                      dsa_key       *public_key,                      unsigned char *out,         unsigned long *outlen){   unsigned long  x;   void          *res;   int            err;   LTC_ARGCHK(private_key != NULL);   LTC_ARGCHK(public_key  != NULL);   LTC_ARGCHK(out         != NULL);   LTC_ARGCHK(outlen      != NULL);   /* make new point */   if ((err = mp_init(&res)) != CRYPT_OK) {      return err;   }   if ((err = mp_exptmod(base, private_key, public_key->p, res)) != CRYPT_OK) {      mp_clear(res);      return err;   }      x = (unsigned long)mp_unsigned_bin_size(res);   if (*outlen < x) {      *outlen = x;      err = CRYPT_BUFFER_OVERFLOW;      goto done;   }   zeromem(out, x);   if ((err = mp_to_unsigned_bin(res, out + (x - mp_unsigned_bin_size(res))))   != CRYPT_OK)          { goto done; }   err     = CRYPT_OK;   *outlen = x;done:   mp_clear(res);   return err;}

/**   Initialize a Pelican state   @param pelmac    The Pelican state to initialize   @param key       The secret key   @param keylen    The length of the secret key (octets)   @return CRYPT_OK if successful*/int pelican_init(pelican_state *pelmac, const unsigned char *key, unsigned long keylen){    int err;    LTC_ARGCHK(pelmac != NULL);    LTC_ARGCHK(key    != NULL);#ifdef LTC_FAST    if (16 % sizeof(LTC_FAST_TYPE)) {        return CRYPT_INVALID_ARG;    }#endif    if ((err = aes_setup(key, keylen, 0, &pelmac->K)) != CRYPT_OK) {       return err;    }    zeromem(pelmac->state, 16);    aes_ecb_encrypt(pelmac->state, pelmac->state, &pelmac->K);    pelmac->buflen = 0;    return CRYPT_OK;}

void AudioSampleBuffer::applyGain (const int channel,                                   const int startSample,                                   int numSamples,                                   const float gain) noexcept{    jassert (isPositiveAndBelow (channel, numChannels));    jassert (startSample >= 0 && startSample + numSamples <= size);    if (gain != 1.0f)    {        float* d = channels [channel] + startSample;        if (gain == 0.0f)        {            zeromem (d, sizeof (float) * (size_t) numSamples);        }        else        {            while (--numSamples >= 0)                *d++ *= gain;        }    }}

int blake2b_init(hash_state *md, unsigned long outlen, const unsigned char *key, unsigned long keylen){   unsigned char P[BLAKE2B_PARAM_SIZE];   int err;   LTC_ARGCHK(md != NULL);   if ((!outlen) || (outlen > BLAKE2B_OUTBYTES))      return CRYPT_INVALID_ARG;   if ((key && !keylen) || (keylen && !key) || (keylen > BLAKE2B_KEYBYTES))      return CRYPT_INVALID_ARG;   XMEMSET(P, 0, sizeof(P));   P[O_DIGEST_LENGTH] = (unsigned char)outlen;   P[O_KEY_LENGTH] = (unsigned char)keylen;   P[O_FANOUT] = 1;   P[O_DEPTH] = 1;   err = blake2b_init_param(md, P);   if (err != CRYPT_OK) return err;   if (key) {      unsigned char block[BLAKE2B_BLOCKBYTES];      XMEMSET(block, 0, BLAKE2B_BLOCKBYTES);      XMEMCPY(block, key, keylen);      blake2b_process(md, block, BLAKE2B_BLOCKBYTES);#ifdef LTC_CLEAN_STACK      zeromem(block, sizeof(block));#endif   }   return CRYPT_OK;}

void AudioDriverCoreAudio::capture_finish() {	if (input_unit) {		lock();		AURenderCallbackStruct callback;		zeromem(&callback, sizeof(AURenderCallbackStruct));		OSStatus result = AudioUnitSetProperty(input_unit, kAudioOutputUnitProperty_SetInputCallback, kAudioUnitScope_Global, 0, &callback, sizeof(callback));		if (result != noErr) {			ERR_PRINT("AudioUnitSetProperty failed");		}		result = AudioUnitUninitialize(input_unit);		if (result != noErr) {			ERR_PRINT("AudioUnitUninitialize failed");		}#ifdef OSX_ENABLED		AudioObjectPropertyAddress prop;		prop.mSelector = kAudioHardwarePropertyDefaultInputDevice;		prop.mScope = kAudioObjectPropertyScopeGlobal;		prop.mElement = kAudioObjectPropertyElementMaster;		result = AudioObjectRemovePropertyListener(kAudioObjectSystemObject, &prop, &input_device_address_cb, this);		if (result != noErr) {			ERR_PRINT("AudioObjectRemovePropertyListener failed");		}#endif		result = AudioComponentInstanceDispose(input_unit);		if (result != noErr) {			ERR_PRINT("AudioComponentInstanceDispose failed");		}		input_unit = NULL;		unlock();	}}

/**  CBC encrypt  @param pt     Plaintext  @param ct     [out] Ciphertext  @param cbc    CBC state  @return CRYPT_OK if successful*/int cbc_encrypt(const unsigned char *pt, unsigned char *ct, symmetric_CBC *cbc){   int x, err;   unsigned char tmp[MAXBLOCKSIZE];   LTC_ARGCHK(pt != NULL);   LTC_ARGCHK(ct != NULL);   LTC_ARGCHK(cbc != NULL);   if ((err = cipher_is_valid(cbc->cipher)) != CRYPT_OK) {       return err;   }      /* is blocklen valid? */   if (cbc->blocklen < 0 || cbc->blocklen > (int)sizeof(cbc->IV)) {      return CRYPT_INVALID_ARG;   }       /* xor IV against plaintext */   for (x = 0; x < cbc->blocklen; x++) {       tmp[x] = pt[x] ^ cbc->IV[x];   }   /* encrypt */   cipher_descriptor[cbc->cipher].ecb_encrypt(tmp, ct, &cbc->key);   /* store IV [ciphertext] for a future block */   for (x = 0; x < cbc->blocklen; x++) {       cbc->IV[x] = ct[x];   }#ifdef LTC_CLEAN_STACK      zeromem(tmp, sizeof(tmp));#endif   return CRYPT_OK;}

unzFile ZipArchive::get_file_handle(String p_file) const {	ERR_FAIL_COND_V(!file_exists(p_file), NULL);	File file = files[p_file];	FileAccess* f = FileAccess::open(packages[file.package].filename, FileAccess::READ);	ERR_FAIL_COND_V(!f, NULL);	zlib_filefunc_def io;	zeromem(&io, sizeof(io));	io.opaque = f;	io.zopen_file = godot_open;	io.zread_file = godot_read;	io.zwrite_file = godot_write;	io.ztell_file = godot_tell;	io.zseek_file = godot_seek;	io.zclose_file = godot_close;	io.zerror_file = godot_testerror;	io.alloc_mem = godot_alloc;	io.free_mem = godot_free;	unzFile pkg = unzOpen2(packages[file.package].filename.utf8().get_data(), &io);	ERR_FAIL_COND_V(!pkg, NULL);	int unz_err = unzGoToFilePos(pkg, &file.file_pos);	ERR_FAIL_COND_V(unz_err != UNZ_OK, NULL);	if (unzOpenCurrentFile(pkg) != UNZ_OK) {		unzClose(pkg);		ERR_FAIL_V(NULL);	};	return pkg;};

/**  Start the PRNG  @param prng     [out] The PRNG state to initialize  @return CRYPT_OK if successful*/  int yarrow_start(prng_state *prng){   int err;      LTC_ARGCHK(prng != NULL);   /* these are the default hash/cipher combo used */#ifdef RIJNDAEL#if    YARROW_AES==0   prng->yarrow.cipher = register_cipher(&rijndael_enc_desc);#elif  YARROW_AES==1   prng->yarrow.cipher = register_cipher(&aes_enc_desc);#elif  YARROW_AES==2   prng->yarrow.cipher = register_cipher(&rijndael_desc);#elif  YARROW_AES==3   prng->yarrow.cipher = register_cipher(&aes_desc);#endif#elif defined(BLOWFISH)   prng->yarrow.cipher = register_cipher(&blowfish_desc);#elif defined(TWOFISH)   prng->yarrow.cipher = register_cipher(&twofish_desc);#elif defined(RC6)   prng->yarrow.cipher = register_cipher(&rc6_desc);#elif defined(RC5)   prng->yarrow.cipher = register_cipher(&rc5_desc);#elif defined(SAFERP)   prng->yarrow.cipher = register_cipher(&saferp_desc);#elif defined(RC2)   prng->yarrow.cipher = register_cipher(&rc2_desc);#elif defined(NOEKEON)      prng->yarrow.cipher = register_cipher(&noekeon_desc);#elif defined(CAST5)   prng->yarrow.cipher = register_cipher(&cast5_desc);#elif defined(XTEA)   prng->yarrow.cipher = register_cipher(&xtea_desc);#elif defined(SAFER)   prng->yarrow.cipher = register_cipher(&safer_sk128_desc);#elif defined(DES)   prng->yarrow.cipher = register_cipher(&des3_desc);#else   #error YARROW needs at least one CIPHER#endif   if ((err = cipher_is_valid(prng->yarrow.cipher)) != CRYPT_OK) {      return err;   }#ifdef SHA256   prng->yarrow.hash   = register_hash(&sha256_desc);#elif defined(SHA512)   prng->yarrow.hash   = register_hash(&sha512_desc);#elif defined(TIGER)   prng->yarrow.hash   = register_hash(&tiger_desc);#elif defined(SHA1)   prng->yarrow.hash   = register_hash(&sha1_desc);#elif defined(RIPEMD160)   prng->yarrow.hash   = register_hash(&rmd160_desc);#elif defined(RIPEMD128)   prng->yarrow.hash   = register_hash(&rmd128_desc);#elif defined(MD5)   prng->yarrow.hash   = register_hash(&md5_desc);#elif defined(MD4)   prng->yarrow.hash   = register_hash(&md4_desc);#elif defined(MD2)   prng->yarrow.hash   = register_hash(&md2_desc);#elif defined(WHIRLPOOL)   prng->yarrow.hash   = register_hash(&whirlpool_desc);#else   #error YARROW needs at least one HASH#endif   if ((err = hash_is_valid(prng->yarrow.hash)) != CRYPT_OK) {      return err;   }   /* zero the memory used */   zeromem(prng->yarrow.pool, sizeof(prng->yarrow.pool));   return CRYPT_OK;}

/**  Sign a hash with DSA  @param in       The hash to sign  @param inlen    The length of the hash to sign  @param r        The "r" integer of the signature (caller must initialize with mp_init() first)  @param s        The "s" integer of the signature (caller must initialize with mp_init() first)  @param prng     An active PRNG state  @param wprng    The index of the PRNG desired  @param key      A private DSA key  @return CRYPT_OK if successful*/int dsa_sign_hash_raw(const unsigned char *in,  unsigned long inlen,                                   void   *r,   void *s,                               prng_state *prng, int wprng, dsa_key *key){   void         *k, *kinv, *tmp;   unsigned char *buf;   int            err;   LTC_ARGCHK(in  != NULL);   LTC_ARGCHK(r   != NULL);   LTC_ARGCHK(s   != NULL);   LTC_ARGCHK(key != NULL);   if ((err = prng_is_valid(wprng)) != CRYPT_OK) {      return err;   }   if (key->type != PK_PRIVATE) {      return CRYPT_PK_NOT_PRIVATE;   }   /* check group order size  */   if (key->qord >= MDSA_MAX_GROUP) {      return CRYPT_INVALID_ARG;   }   buf = XMALLOC(MDSA_MAX_GROUP);   if (buf == NULL) {      return CRYPT_MEM;   }   /* Init our temps */   if ((err = mp_init_multi(&k, &kinv, &tmp, NULL)) != CRYPT_OK)                       { goto ERRBUF; }retry:   do {      /* gen random k */      if (prng_descriptor[wprng].read(buf, key->qord, prng) != (unsigned long)key->qord) {         err = CRYPT_ERROR_READPRNG;         goto error;      }      /* read k */      if ((err = mp_read_unsigned_bin(k, buf, key->qord)) != CRYPT_OK)                 { goto error; }      /* k > 1 ? */      if (mp_cmp_d(k, 1) != LTC_MP_GT)                                                 { goto retry; }      /* test gcd */      if ((err = mp_gcd(k, key->q, tmp)) != CRYPT_OK)                                  { goto error; }   } while (mp_cmp_d(tmp, 1) != LTC_MP_EQ);   /* now find 1/k mod q */   if ((err = mp_invmod(k, key->q, kinv)) != CRYPT_OK)                                 { goto error; }   /* now find r = g^k mod p mod q */   if ((err = mp_exptmod(key->g, k, key->p, r)) != CRYPT_OK)                           { goto error; }   if ((err = mp_mod(r, key->q, r)) != CRYPT_OK)                                       { goto error; }   if (mp_iszero(r) == LTC_MP_YES)                                                     { goto retry; }   /* now find s = (in + xr)/k mod q */   if ((err = mp_read_unsigned_bin(tmp, (unsigned char *)in, inlen)) != CRYPT_OK)      { goto error; }   if ((err = mp_mul(key->x, r, s)) != CRYPT_OK)                                       { goto error; }   if ((err = mp_add(s, tmp, s)) != CRYPT_OK)                                          { goto error; }   if ((err = mp_mulmod(s, kinv, key->q, s)) != CRYPT_OK)                              { goto error; }   if (mp_iszero(s) == LTC_MP_YES)                                                     { goto retry; }   err = CRYPT_OK;error:    mp_clear_multi(k, kinv, tmp, NULL);ERRBUF:#ifdef LTC_CLEAN_STACK   zeromem(buf, MDSA_MAX_GROUP);#endif   XFREE(buf);   return err;}

/**  Encrypt a symmetric key with ECC   @param in         The symmetric key you want to encrypt  @param inlen      The length of the key to encrypt (octets)  @param out        [out] The destination for the ciphertext  @param outlen     [in/out] The max size and resulting size of the ciphertext  @param prng       An active PRNG state  @param wprng      The index of the PRNG you wish to use   @param hash       The index of the hash you want to use   @param key        The ECC key you want to encrypt to  @return CRYPT_OK if successful*/int ecc_encrypt_key(const unsigned char *in,   unsigned long inlen,                          unsigned char *out,  unsigned long *outlen,                           prng_state *prng, int wprng, int hash,                           ecc_key *key){    unsigned char *pub_expt, *ecc_shared, *skey;    ecc_key        pubkey;    unsigned long  x, y, pubkeysize;    int            err;    LTC_ARGCHK(in      != NULL);    LTC_ARGCHK(out     != NULL);    LTC_ARGCHK(outlen  != NULL);    LTC_ARGCHK(key     != NULL);    /* check that wprng/cipher/hash are not invalid */    if ((err = prng_is_valid(wprng)) != CRYPT_OK) {       return err;    }    if ((err = hash_is_valid(hash)) != CRYPT_OK) {       return err;    }    if (inlen > hash_descriptor[hash].hashsize) {       return CRYPT_INVALID_HASH;    }    /* make a random key and export the public copy */    if ((err = ecc_make_key_ex(prng, wprng, &pubkey, key->dp)) != CRYPT_OK) {       return err;    }    pub_expt   = XMALLOC(ECC_BUF_SIZE);    ecc_shared = XMALLOC(ECC_BUF_SIZE);    skey       = XMALLOC(MAXBLOCKSIZE);    if (pub_expt == NULL || ecc_shared == NULL || skey == NULL) {       if (pub_expt != NULL) {          XFREE(pub_expt);       }       if (ecc_shared != NULL) {          XFREE(ecc_shared);       }       if (skey != NULL) {          XFREE(skey);       }       ecc_free(&pubkey);       return CRYPT_MEM;    }    pubkeysize = ECC_BUF_SIZE;    if ((err = ecc_export(pub_expt, &pubkeysize, PK_PUBLIC, &pubkey)) != CRYPT_OK) {       ecc_free(&pubkey);       goto LBL_ERR;    }        /* make random key */    x        = ECC_BUF_SIZE;    if ((err = ecc_shared_secret(&pubkey, key, ecc_shared, &x)) != CRYPT_OK) {       ecc_free(&pubkey);       goto LBL_ERR;    }    ecc_free(&pubkey);    y = MAXBLOCKSIZE;    if ((err = hash_memory(hash, ecc_shared, x, skey, &y)) != CRYPT_OK) {       goto LBL_ERR;    }        /* Encrypt key */    for (x = 0; x < inlen; x++) {      skey[x] ^= in[x];    }    err = der_encode_sequence_multi(out, outlen,                                    LTC_ASN1_OBJECT_IDENTIFIER,  hash_descriptor[hash].OIDlen,   hash_descriptor[hash].OID,                                    LTC_ASN1_OCTET_STRING,       pubkeysize,                     pub_expt,                                    LTC_ASN1_OCTET_STRING,       inlen,                          skey,                                    LTC_ASN1_EOL,                0UL,                            NULL);LBL_ERR:#ifdef LTC_CLEAN_STACK    /* clean up */    zeromem(pub_expt,   ECC_BUF_SIZE);    zeromem(ecc_shared, ECC_BUF_SIZE);    zeromem(skey,       MAXBLOCKSIZE);#endif    XFREE(skey);//.........这里部分代码省略.........

IIRCoefficients::IIRCoefficients() noexcept{    zeromem (coefficients, sizeof (coefficients));}

//.........这里部分代码省略.........	}	/* Make sure PC is 4-byte aligned, except for Thumb */	if ((pc & 0x3) && !thumb)		goto invalid_param;	/*	 * EL3 controls register width of the immediate lower EL only. Expect	 * this request from EL2/Hyp unless:	 *	 * - EL2 is not implemented;	 * - EL2 is implemented, but was disabled. This can be inferred from	 *   SCR_EL3.HCE.	 */	from_el2 = caller_64 ? (GET_EL(spsr) == MODE_EL2) :		(GET_M32(spsr) == MODE32_hyp);	scr = read_ctx_reg(el3_ctx, CTX_SCR_EL3);	if (!from_el2) {		/* The call is from NS privilege level other than HYP */		/*		 * Disallow switching state if there's a Hypervisor in place;		 * this request must be taken up with the Hypervisor instead.		 */		if (scr & SCR_HCE_BIT)			goto exec_denied;	}	/*	 * Return to the caller using the same endianness. Extract	 * endianness bit from the respective system control register	 * directly.	 */	sctlr = from_el2 ? read_sctlr_el2() : read_sctlr_el1();	endianness = !!(sctlr & SCTLR_EE_BIT);	/* Construct SPSR for the exception state we're about to switch to */	if (caller_64) {		int impl;		/*		 * Switching from AArch64 to AArch32. Ensure this CPU implements		 * the target EL in AArch32.		 */		impl = from_el2 ? EL_IMPLEMENTED(2) : EL_IMPLEMENTED(1);		if (impl != EL_IMPL_A64_A32)			goto exec_denied;		/* Return to the equivalent AArch32 privilege level */		el = from_el2 ? MODE32_hyp : MODE32_svc;		spsr = SPSR_MODE32(el, thumb ? SPSR_T_THUMB : SPSR_T_ARM,				endianness, DISABLE_ALL_EXCEPTIONS);	} else {		/*		 * Switching from AArch32 to AArch64. Since it's not possible to		 * implement an EL as AArch32-only (from which this call was		 * raised), it's safe to assume AArch64 is also implemented.		 */		el = from_el2 ? MODE_EL2 : MODE_EL1;		spsr = SPSR_64(el, MODE_SP_ELX, DISABLE_ALL_EXCEPTIONS);	}	/*	 * Use the context management library to re-initialize the existing	 * context with the execution state flipped. Since the library takes	 * entry_point_info_t pointer as the argument, construct a dummy one	 * with PC, state width, endianness, security etc. appropriately set.	 * Other entries in the entry point structure are irrelevant for	 * purpose.	 */	zeromem(&ep, sizeof(ep));	ep.pc = pc;	ep.spsr = spsr;	SET_PARAM_HEAD(&ep, PARAM_EP, VERSION_1,			((endianness ? EP_EE_BIG : EP_EE_LITTLE) | NON_SECURE |			 EP_ST_DISABLE));	/*	 * Re-initialize the system register context, and exit EL3 as if for the	 * first time. State switch is effectively a soft reset of the	 * calling EL.	 */	cm_init_my_context(&ep);	cm_prepare_el3_exit(NON_SECURE);	/*	 * State switch success. The caller of SMC wouldn't see the SMC	 * returning. Instead, execution starts at the supplied entry point,	 * with context pointers populated in registers 0 and 1.	 */	SMC_RET2(handle, cookie_hi, cookie_lo);invalid_param:	SMC_RET1(handle, STATE_SW_E_PARAM);exec_denied:#endif	/* State switch denied */	SMC_RET1(handle, STATE_SW_E_DENIED);}

HANDLE WINAPI EXP_NAME(OpenPlugin)(int OpenFrom, INT_PTR Item){    struct FarMenuItem aMenuItems[7];    int nItems;    (void)OpenFrom;    (void)Item;    bThisUseSelection=bUseSelection;    bThisAutoNext=bAutoNext;    bStopOnFound=FALSE;    zeromem(aMenuItems, sizeof(aMenuItems));#if defined(WINPORT_DIRECT)    aMenuItems[0].Text = GetMsg(MSearchForward);    aMenuItems[1].Text = GetMsg(MSearchBackward);#else    _tstrcpy(aMenuItems[0].Text, GetMsg(MSearchForward));    _tstrcpy(aMenuItems[1].Text, GetMsg(MSearchBackward));#endif    aMenuItems[2].Separator=TRUE;    if( OpenFrom==OPEN_EDITOR ) {#if defined(WINPORT_DIRECT)        aMenuItems[3].Text = GetMsg(MFindNext);        aMenuItems[4].Text = GetMsg(MFindPrevious);#else        _tstrcpy(aMenuItems[3].Text, GetMsg(MFindNext));        _tstrcpy(aMenuItems[4].Text, GetMsg(MFindPrevious));#endif        aMenuItems[5].Separator=TRUE;        nItems=sizeof(aMenuItems)/sizeof(aMenuItems[0]);    }else{        nItems=4;    }#if defined(WINPORT_DIRECT)    aMenuItems[nItems-1].Text = GetMsg(MSetup);#else    _tstrcpy(aMenuItems[nItems-1].Text, GetMsg(MSetup));#endif    aMenuItems[bReverse?1:0].Selected=TRUE;Menu:    switch( apiMenu(ModuleNumber,-1,-1,0,FMENU_WRAPMODE,GetMsg(MIncSearch),NULL,(TCHAR*)sHlfMenu,NULL,NULL,aMenuItems,nItems) ){    case 0:  bReverse=FALSE;             break;    case 1:  bReverse=TRUE;             break;    case 3:  if( OpenFrom==OPEN_EDITOR ) {                 bReverse=FALSE;                 goto Auto;    case 4:      bReverse=TRUE;Auto:            bThisUseSelection=TRUE;                 bThisAutoNext=TRUE;                 bStopOnFound=TRUE;                 break;             }    case 6:  EXP_NAME(Configure)(0);             goto Menu;    default: return INVALID_HANDLE_VALUE;    }    if( OpenFrom==OPEN_EDITOR ) SearchLoopEditor();#ifdef VIEWVER_SUPPORT    else SearchLoopViewer();#endif    return INVALID_HANDLE_VALUE;}

bool AudioFormatReader::read (int* const* destSamples,                              int numDestChannels,                              int64 startSampleInSource,                              int numSamplesToRead,                              const bool fillLeftoverChannelsWithCopies){    jassert (numDestChannels > 0); // you have to actually give this some channels to work with!    int startOffsetInDestBuffer = 0;    if (startSampleInSource < 0)    {        const int silence = (int) jmin (-startSampleInSource, (int64) numSamplesToRead);        for (int i = numDestChannels; --i >= 0;)            if (destSamples[i] != nullptr)                zeromem (destSamples[i], sizeof (int) * (size_t) silence);        startOffsetInDestBuffer += silence;        numSamplesToRead -= silence;        startSampleInSource = 0;    }    if (numSamplesToRead <= 0)        return true;    if (! readSamples (const_cast <int**> (destSamples),                       jmin ((int) numChannels, numDestChannels), startOffsetInDestBuffer,                       startSampleInSource, numSamplesToRead))        return false;    if (numDestChannels > (int) numChannels)    {        if (fillLeftoverChannelsWithCopies)        {            int* lastFullChannel = destSamples[0];            for (int i = (int) numChannels; --i > 0;)            {                if (destSamples[i] != nullptr)                {                    lastFullChannel = destSamples[i];                    break;                }            }            if (lastFullChannel != nullptr)                for (int i = (int) numChannels; i < numDestChannels; ++i)                    if (destSamples[i] != nullptr)                        memcpy (destSamples[i], lastFullChannel, sizeof (int) * (size_t) numSamplesToRead);        }        else        {            for (int i = (int) numChannels; i < numDestChannels; ++i)                if (destSamples[i] != nullptr)                    zeromem (destSamples[i], sizeof (int) * (size_t) numSamplesToRead);        }    }    return true;}

int f8_encrypt(const unsigned char *pt, unsigned char *ct, unsigned long len, symmetric_F8 *f8){   int           err, x;   unsigned char buf[MAXBLOCKSIZE];   LTC_ARGCHK(pt != NULL);   LTC_ARGCHK(ct != NULL);   LTC_ARGCHK(f8 != NULL);   if ((err = cipher_is_valid(f8->cipher)) != CRYPT_OK) {       return err;   }      /* is blocklen/padlen valid? */   if (f8->blocklen < 0 || f8->blocklen > (int)sizeof(f8->IV) ||       f8->padlen   < 0 || f8->padlen   > (int)sizeof(f8->IV)) {      return CRYPT_INVALID_ARG;   }      zeromem(buf, sizeof(buf));   /* make sure the pad is empty */   if (f8->padlen == f8->blocklen) {      /* xor of IV, MIV and blockcnt == what goes into cipher */      STORE32H(f8->blockcnt, (buf+(f8->blocklen-4)));      ++(f8->blockcnt);      for (x = 0; x < f8->blocklen; x++) {          f8->IV[x] ^= f8->MIV[x] ^ buf[x];      }      if ((err = cipher_descriptor[f8->cipher].ecb_encrypt(f8->IV, f8->IV, &f8->key)) != CRYPT_OK) {         return err;      }      f8->padlen = 0;   }#ifdef LTC_FAST   if (f8->padlen == 0) {      while (len >= (unsigned long)f8->blocklen) {         STORE32H(f8->blockcnt, (buf+(f8->blocklen-4)));         ++(f8->blockcnt);         for (x = 0; x < f8->blocklen; x += sizeof(LTC_FAST_TYPE)) {             *((LTC_FAST_TYPE*)(&ct[x])) = *((LTC_FAST_TYPE*)(&pt[x])) ^ *((LTC_FAST_TYPE*)(&f8->IV[x]));             *((LTC_FAST_TYPE*)(&f8->IV[x])) ^= *((LTC_FAST_TYPE*)(&f8->MIV[x])) ^ *((LTC_FAST_TYPE*)(&buf[x]));         }         if ((err = cipher_descriptor[f8->cipher].ecb_encrypt(f8->IV, f8->IV, &f8->key)) != CRYPT_OK) {            return err;         }         len -= x;         pt  += x;         ct  += x;      }   }#endif                while (len > 0) {       if (f8->padlen == f8->blocklen) {          /* xor of IV, MIV and blockcnt == what goes into cipher */          STORE32H(f8->blockcnt, (buf+(f8->blocklen-4)));          ++(f8->blockcnt);          for (x = 0; x < f8->blocklen; x++) {              f8->IV[x] ^= f8->MIV[x] ^ buf[x];          }          if ((err = cipher_descriptor[f8->cipher].ecb_encrypt(f8->IV, f8->IV, &f8->key)) != CRYPT_OK) {             return err;          }          f8->padlen = 0;       }       *ct++ = *pt++ ^ f8->IV[f8->padlen++];       --len;   }   return CRYPT_OK;}

int rand_prime(void *N, long len, prng_state *prng, int wprng){    int            err, res, type;    unsigned char *buf;    LTC_ARGCHK(N != NULL);    /* get type */    if (len < 0) {        type = USE_BBS;        len = -len;    } else {        type = 0;    }    /* allow sizes between 2 and 512 bytes for a prime size */    if (len < 2 || len > 512) {        return CRYPT_INVALID_PRIME_SIZE;    }    /* valid PRNG? Better be! */    if ((err = prng_is_valid(wprng)) != CRYPT_OK) {        return err;    }    /* allocate buffer to work with */    buf = XCALLOC(1, len);    if (buf == NULL) {        return CRYPT_MEM;    }    do {        /* generate value */        if (prng_descriptor[wprng].read(buf, len, prng) != (unsigned long)len) {            XFREE(buf);            return CRYPT_ERROR_READPRNG;        }        /* munge bits */        buf[0]     |= 0x80 | 0x40;        buf[len-1] |= 0x01 | ((type & USE_BBS) ? 0x02 : 0x00);        /* load value */        if ((err = mp_read_unsigned_bin(N, buf, len)) != CRYPT_OK) {            XFREE(buf);            return err;        }        /* test */        if ((err = mp_prime_is_prime(N, 8, &res)) != CRYPT_OK) {            XFREE(buf);            return err;        }    } while (res == LTC_MP_NO);#ifdef LTC_CLEAN_STACK    zeromem(buf, len);#endif    XFREE(buf);    return CRYPT_OK;}