int ssh_pki_signature_verify_blob(ssh_session session,
ssh_string sig_blob,
const ssh_key key,
unsigned char *digest,
size_t dlen)
{
ssh_signature sig;
int rc;
rc = ssh_pki_import_signature_blob(sig_blob, key, &sig);
if (rc < 0) {
return SSH_ERROR;
}
SSH_LOG(SSH_LOG_FUNCTIONS,
"Going to verify a %s type signature",
key->type_c);
if (key->type == SSH_KEYTYPE_ECDSA) {
#if HAVE_ECC
unsigned char ehash[EVP_DIGEST_LEN] = {0};
uint32_t elen;
evp(key->ecdsa_nid, digest, dlen, ehash, &elen);
#ifdef DEBUG_CRYPTO
ssh_print_hexa("Hash to be verified with ecdsa",
ehash, elen);
#endif
rc = pki_signature_verify(session,
sig,
key,
ehash,
elen);
#endif
} else if (key->type == SSH_KEYTYPE_ED25519) {
rc = pki_signature_verify(session, sig, key, digest, dlen);
} else {
unsigned char hash[SHA_DIGEST_LEN] = {0};
sha1(digest, dlen, hash);
#ifdef DEBUG_CRYPTO
ssh_print_hexa("Hash to be verified with dsa", hash, SHA_DIGEST_LEN);
#endif
rc = pki_signature_verify(session,
sig,
key,
hash,
SHA_DIGEST_LEN);
}
ssh_signature_free(sig);
return rc;
}
ssh_string ssh_srv_pki_do_sign_sessionid(ssh_session session,
const ssh_key privkey)
{
struct ssh_crypto_struct *crypto;
ssh_signature sig = NULL;
ssh_string sig_blob;
int rc;
if (session == NULL || privkey == NULL || !ssh_key_is_private(privkey)) {
return NULL;
}
crypto = session->next_crypto ? session->next_crypto :
session->current_crypto;
if (crypto->secret_hash == NULL){
ssh_set_error(session,SSH_FATAL,"Missing secret_hash");
return NULL;
}
if (privkey->type == SSH_KEYTYPE_ECDSA) {
#ifdef HAVE_ECC
unsigned char ehash[EVP_DIGEST_LEN] = {0};
uint32_t elen;
evp(privkey->ecdsa_nid, crypto->secret_hash, crypto->digest_len,
ehash, &elen);
#ifdef DEBUG_CRYPTO
ssh_print_hexa("Hash being signed", ehash, elen);
#endif
sig = pki_do_sign_sessionid(privkey, ehash, elen);
if (sig == NULL) {
return NULL;
}
#endif
} else if (privkey->type == SSH_KEYTYPE_ED25519) {
sig = ssh_signature_new();
if (sig == NULL){
return NULL;
}
sig->type = privkey->type;
sig->type_c = privkey->type_c;
rc = pki_ed25519_sign(privkey,
sig,
crypto->secret_hash,
crypto->digest_len);
if (rc != SSH_OK){
ssh_signature_free(sig);
sig = NULL;
}
} else {
unsigned char hash[SHA_DIGEST_LEN] = {0};
SHACTX ctx;
ctx = sha1_init();
if (ctx == NULL) {
return NULL;
}
sha1_update(ctx, crypto->secret_hash, crypto->digest_len);
sha1_final(hash, ctx);
#ifdef DEBUG_CRYPTO
ssh_print_hexa("Hash being signed", hash, SHA_DIGEST_LEN);
#endif
sig = pki_do_sign_sessionid(privkey, hash, SHA_DIGEST_LEN);
if (sig == NULL) {
return NULL;
}
}
rc = ssh_pki_export_signature_blob(sig, &sig_blob);
ssh_signature_free(sig);
if (rc < 0) {
return NULL;
}
return sig_blob;
}
/* Called by the scheduler for every time slice in which this instrument
should run. This is where the real work of the instrument is done.
*/
int LPCPLAY::run()
{
int n = 0;
float out[2]; /* Space for only 2 output chans! */
#if 0
printf("\nLPCPLAY::run()\n");
#endif
// Samples may have been left over from end of previous run's block
if (_leftOver > 0)
{
int toAdd = min(_leftOver, framesToRun());
#ifdef debug
printf("using %d leftover samps starting at offset %d\n",
_leftOver, _savedOffset);
#endif
rtbaddout(&_alpvals[_savedOffset], toAdd);
increment(toAdd);
n += toAdd;
_leftOver -= toAdd;
_savedOffset += toAdd;
}
/* framesToRun() returns the number of sample frames -- 1 sample for each
channel -- that we have to write during this scheduler time slice.
*/
for (; n < framesToRun(); n += _counter) {
double p[12];
update(p, 12);
_amp = p[2];
_pitch = p[3];
_transposition = ABS(_pitch);
_warpFactor = p[6];
_reson_is_on = p[7] ? true : false;
_cf_fact = p[7];
_bw_fact = p[8];
int loc;
if ( _unvoiced_rate && !_voiced )
{
++_frameno; /* if unvoiced set to normal rate */
}
else
{
_frameno = _frame1 + ((float)(currentFrame())/nSamps()) * _frames;
}
#if 0
printf("frame %g\n", _frameno);
#endif
if (_dataSet->getFrame(_frameno,_coeffs) == -1)
break;
// If requested, stabilize this frame before using
if (_autoCorrect)
stabilize(_coeffs, _nPoles);
float buzamp = getVoicedAmp(_coeffs[THRESH]);
_voiced = (buzamp > 0.1); /* voiced = 0 for 10:1 noise */
float noisamp = (1.0 - buzamp) * _randamp; /* for now */
_ampmlt = _amp * _coeffs[RESIDAMP];
if (_coeffs[RMSAMP] < _cutoff)
_ampmlt = 0;
float cps = tablei(currentFrame(),_pchvals,_tblvals);
float newpch = cps;
// If input pitch was specified as -X.YZ, use this as actual pitch
if ((_pitch < 0) && (ABS(_pitch) >= 1))
newpch = _transposition;
if (_reson_is_on) {
/* If _cf_fact is greater than 20, treat as absolute freq.
Else treat as factor.
If _bw_fact is greater than 20, treat as absolute freq.
Else treat as factor (i.e., cf * factor == bw).
*/
float cf = (_cf_fact < 20.0) ? _cf_fact*cps : _cf_fact;
float bw = (_bw_fact < 20.0) ? cf * _bw_fact : _bw_fact;
rszset(SR, cf, bw, 1., _rsnetc);
#ifdef debug
printf("cf %g bw %g cps %g\n", cf, bw,cps);
#endif
}
float si = newpch * _magic;
float *cpoint = _coeffs + 4;
if (_warpFactor != 0.0)
{
float warp = (_warpFactor > 1.) ? .0001 : _warpFactor;
_ampmlt *= _warpPole.set(warp, cpoint, _nPoles);
}
if (_hnfactor < 1.0)
{
buzamp *= _hnfactor; /* compensate for gain increase */
}
float hn = (_hnfactor <= 1.0) ? (int)(_hnfactor*_srd2/newpch)-2 : _hnfactor;
_counter = int(((float)SR/(newpch * _perperiod) ) * .5);
_counter = (_counter > (nSamps() - currentFrame())) ? nSamps() - currentFrame() : _counter;
#ifdef debug
printf("fr: %g err: %g bzamp: %g noisamp: %g pch: %g ctr: %d\n",
_frameno,_coeffs[THRESH],_ampmlt*buzamp,_ampmlt*noisamp,newpch,_counter);
#endif
if (_counter <= 0)
break;
// Catch bad pitches which generate array overruns
else if (_counter > _arrayLen) {
rtcmix_warn("LPCPLAY", "Counter exceeded array size -- limiting. Frame pitch: %f", newpch);
_counter = _arrayLen;
}
bbuzz(_ampmlt*buzamp,si,hn,_sineFun,&_phs,_buzvals,_counter);
#ifdef debug
printf("\t _buzvals[0] = %g\n", _buzvals[0]);
#endif
l_brrand(_ampmlt*noisamp,_noisvals,_counter); /* TEMPORARY */
#ifdef debug
printf("\t _noisvals[0] = %g\n", _noisvals[0]);
#endif
for (loc=0; loc<_counter; loc++) {
_buzvals[loc] += _noisvals[loc]; /* add voiced and unvoiced */
}
if (_warpFactor) {
float warp = (_warpFactor > 1.) ? shift(_coeffs[PITCH],newpch,(float)SR) : _warpFactor;
#ifdef debug
printf("\tpch: %f newpch: %f d: %f\n",_coeffs[PITCH], newpch, warp);
#endif
/*************
warp = ABS(warp) > .2 ? SIGN(warp) * .15 : warp;
***************/
_warpPole.run(_buzvals, warp, cpoint, _alpvals, _counter);
}
else
{
ballpole(_buzvals,&_jcount,_nPoles,_past,cpoint,_alpvals,_counter);
}
#ifdef debug
{ int x; float maxamp=0; for (x=0;x<_counter;x++) { if (ABS(_alpvals[x]) > ABS(maxamp)) maxamp = _alpvals[x]; }
printf("\t maxamp = %g\n", maxamp);
}
#endif
if (_reson_is_on)
bresonz(_alpvals,_rsnetc,_alpvals,_counter);
// Apply envelope last
float envelope = evp(currentFrame(),_envFun,_envFun,_evals);
bmultf(_alpvals, envelope, _counter);
int sampsToAdd = min(_counter, framesToRun() - n);
/* Write this block to the output buffer. */
rtbaddout(_alpvals, sampsToAdd);
/* Keep track of how many sample frames this instrument has generated. */
increment(sampsToAdd);
}
// Handle case where last synthesized block extended beyond framesToRun()
if (n > framesToRun())
{
_leftOver = n - framesToRun();
_savedOffset = _counter - _leftOver;
#ifdef debug
printf("saving %d samples left over at offset %d\n", _leftOver, _savedOffset);
#endif
}
return framesToRun();
}
