UbiquitousOS
/
OpenCloudOS-Kernel
mirror of https://gitee.com/OpenCloudOS/OpenCloudOS-Kernel.git
11
0
Fork 0
Code Issues Projects Releases Wiki Activity
OpenCloudOS-Kernel/drivers/s390/crypto/z90hardware.c

2532 lines
67 KiB
C
Raw Blame History

/*
* linux/drivers/s390/crypto/z90hardware.c
*
* z90crypt 1.3.3
*
* Copyright (C) 2001, 2005 IBM Corporation
* Author(s): Robert Burroughs (burrough@us.ibm.com)
* Eric Rossman (edrossma@us.ibm.com)
*
* Hotplug & misc device support: Jochen Roehrig (roehrig@de.ibm.com)
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2, or (at your option)
* any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include <asm/uaccess.h>
#include <linux/compiler.h>
#include <linux/delay.h>
#include <linux/init.h>
#include <linux/module.h>
#include "z90crypt.h"
#include "z90common.h"
struct cca_token_hdr {
unsigned char token_identifier;
unsigned char version;
unsigned short token_length;
unsigned char reserved[4];
};
#define CCA_TKN_HDR_ID_EXT 0x1E
struct cca_private_ext_ME_sec {
unsigned char section_identifier;
unsigned char version;
unsigned short section_length;
unsigned char private_key_hash[20];
unsigned char reserved1[4];
unsigned char key_format;
unsigned char reserved2;
unsigned char key_name_hash[20];
unsigned char key_use_flags[4];
unsigned char reserved3[6];
unsigned char reserved4[24];
unsigned char confounder[24];
unsigned char exponent[128];
unsigned char modulus[128];
};
#define CCA_PVT_USAGE_ALL 0x80
struct cca_public_sec {
unsigned char section_identifier;
unsigned char version;
unsigned short section_length;
unsigned char reserved[2];
unsigned short exponent_len;
unsigned short modulus_bit_len;
unsigned short modulus_byte_len;
unsigned char exponent[3];
};
struct cca_private_ext_ME {
struct cca_token_hdr pvtMEHdr;
struct cca_private_ext_ME_sec pvtMESec;
struct cca_public_sec pubMESec;
};
struct cca_public_key {
struct cca_token_hdr pubHdr;
struct cca_public_sec pubSec;
};
struct cca_pvt_ext_CRT_sec {
unsigned char section_identifier;
unsigned char version;
unsigned short section_length;
unsigned char private_key_hash[20];
unsigned char reserved1[4];
unsigned char key_format;
unsigned char reserved2;
unsigned char key_name_hash[20];
unsigned char key_use_flags[4];
unsigned short p_len;
unsigned short q_len;
unsigned short dp_len;
unsigned short dq_len;
unsigned short u_len;
unsigned short mod_len;
unsigned char reserved3[4];
unsigned short pad_len;
unsigned char reserved4[52];
unsigned char confounder[8];
};
#define CCA_PVT_EXT_CRT_SEC_ID_PVT 0x08
#define CCA_PVT_EXT_CRT_SEC_FMT_CL 0x40
struct cca_private_ext_CRT {
struct cca_token_hdr pvtCrtHdr;
struct cca_pvt_ext_CRT_sec pvtCrtSec;
struct cca_public_sec pubCrtSec;
};
struct ap_status_word {
unsigned char q_stat_flags;
unsigned char response_code;
unsigned char reserved[2];
};
#define AP_Q_STATUS_EMPTY 0x80
#define AP_Q_STATUS_REPLIES_WAITING 0x40
#define AP_Q_STATUS_ARRAY_FULL 0x20
#define AP_RESPONSE_NORMAL 0x00
#define AP_RESPONSE_Q_NOT_AVAIL 0x01
#define AP_RESPONSE_RESET_IN_PROGRESS 0x02
#define AP_RESPONSE_DECONFIGURED 0x03
#define AP_RESPONSE_CHECKSTOPPED 0x04
#define AP_RESPONSE_BUSY 0x05
#define AP_RESPONSE_Q_FULL 0x10
#define AP_RESPONSE_NO_PENDING_REPLY 0x10
#define AP_RESPONSE_INDEX_TOO_BIG 0x11
#define AP_RESPONSE_NO_FIRST_PART 0x13
#define AP_RESPONSE_MESSAGE_TOO_BIG 0x15
#define AP_MAX_CDX_BITL 4
#define AP_RQID_RESERVED_BITL 4
#define SKIP_BITL (AP_MAX_CDX_BITL + AP_RQID_RESERVED_BITL)
struct type4_hdr {
unsigned char reserved1;
unsigned char msg_type_code;
unsigned short msg_len;
unsigned char request_code;
unsigned char msg_fmt;
unsigned short reserved2;
};
#define TYPE4_TYPE_CODE 0x04
#define TYPE4_REQU_CODE 0x40
#define TYPE4_SME_LEN 0x0188
#define TYPE4_LME_LEN 0x0308
#define TYPE4_SCR_LEN 0x01E0
#define TYPE4_LCR_LEN 0x03A0
#define TYPE4_SME_FMT 0x00
#define TYPE4_LME_FMT 0x10
#define TYPE4_SCR_FMT 0x40
#define TYPE4_LCR_FMT 0x50
struct type4_sme {
struct type4_hdr header;
unsigned char message[128];
unsigned char exponent[128];
unsigned char modulus[128];
};
struct type4_lme {
struct type4_hdr header;
unsigned char message[256];
unsigned char exponent[256];
unsigned char modulus[256];
};
struct type4_scr {
struct type4_hdr header;
unsigned char message[128];
unsigned char dp[72];
unsigned char dq[64];
unsigned char p[72];
unsigned char q[64];
unsigned char u[72];
};
struct type4_lcr {
struct type4_hdr header;
unsigned char message[256];
unsigned char dp[136];
unsigned char dq[128];
unsigned char p[136];
unsigned char q[128];
unsigned char u[136];
};
union type4_msg {
struct type4_sme sme;
struct type4_lme lme;
struct type4_scr scr;
struct type4_lcr lcr;
};
struct type84_hdr {
unsigned char reserved1;
unsigned char code;
unsigned short len;
unsigned char reserved2[4];
};
#define TYPE84_RSP_CODE 0x84
struct type6_hdr {
unsigned char reserved1;
unsigned char type;
unsigned char reserved2[2];
unsigned char right[4];
unsigned char reserved3[2];
unsigned char reserved4[2];
unsigned char apfs[4];
unsigned int offset1;
unsigned int offset2;
unsigned int offset3;
unsigned int offset4;
unsigned char agent_id[16];
unsigned char rqid[2];
unsigned char reserved5[2];
unsigned char function_code[2];
unsigned char reserved6[2];
unsigned int ToCardLen1;
unsigned int ToCardLen2;
unsigned int ToCardLen3;
unsigned int ToCardLen4;
unsigned int FromCardLen1;
unsigned int FromCardLen2;
unsigned int FromCardLen3;
unsigned int FromCardLen4;
};
struct CPRB {
unsigned char cprb_len[2];
unsigned char cprb_ver_id;
unsigned char pad_000;
unsigned char srpi_rtcode[4];
unsigned char srpi_verb;
unsigned char flags;
unsigned char func_id[2];
unsigned char checkpoint_flag;
unsigned char resv2;
unsigned char req_parml[2];
unsigned char req_parmp[4];
unsigned char req_datal[4];
unsigned char req_datap[4];
unsigned char rpl_parml[2];
unsigned char pad_001[2];
unsigned char rpl_parmp[4];
unsigned char rpl_datal[4];
unsigned char rpl_datap[4];
unsigned char ccp_rscode[2];
unsigned char ccp_rtcode[2];
unsigned char repd_parml[2];
unsigned char mac_data_len[2];
unsigned char repd_datal[4];
unsigned char req_pc[2];
unsigned char res_origin[8];
unsigned char mac_value[8];
unsigned char logon_id[8];
unsigned char usage_domain[2];
unsigned char resv3[18];
unsigned char svr_namel[2];
unsigned char svr_name[8];
};
struct type6_msg {
struct type6_hdr header;
struct CPRB CPRB;
};
struct type86_hdr {
unsigned char reserved1;
unsigned char type;
unsigned char format;
unsigned char reserved2;
unsigned char reply_code;
unsigned char reserved3[3];
};
#define TYPE86_RSP_CODE 0x86
#define TYPE86_FMT2 0x02
struct type86_fmt2_msg {
struct type86_hdr header;
unsigned char reserved[4];
unsigned char apfs[4];
unsigned int count1;
unsigned int offset1;
unsigned int count2;
unsigned int offset2;
unsigned int count3;
unsigned int offset3;
unsigned int count4;
unsigned int offset4;
};
static struct type6_hdr static_type6_hdr = {
0x00,
0x06,
{0x00,0x00},
{0x00,0x00,0x00,0x00},
{0x00,0x00},
{0x00,0x00},
{0x00,0x00,0x00,0x00},
0x00000058,
0x00000000,
0x00000000,
0x00000000,
{0x01,0x00,0x43,0x43,0x41,0x2D,0x41,0x50,
0x50,0x4C,0x20,0x20,0x20,0x01,0x01,0x01},
{0x00,0x00},
{0x00,0x00},
{0x50,0x44},
{0x00,0x00},
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000
};
static struct type6_hdr static_type6_hdrX = {
0x00,
0x06,
{0x00,0x00},
{0x00,0x00,0x00,0x00},
{0x00,0x00},
{0x00,0x00},
{0x00,0x00,0x00,0x00},
0x00000058,
0x00000000,
0x00000000,
0x00000000,
{0x43,0x41,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00},
{0x00,0x00},
{0x50,0x44},
{0x00,0x00},
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000
};
static struct CPRB static_cprb = {
{0x70,0x00},
0x41,
0x00,
{0x00,0x00,0x00,0x00},
0x00,
0x00,
{0x54,0x32},
0x01,
0x00,
{0x00,0x00},
{0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00},
{0x00,0x00},
{0x00,0x00},
{0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00},
{0x00,0x00},
{0x00,0x00},
{0x00,0x00},
{0x00,0x00},
{0x00,0x00,0x00,0x00},
{0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00},
{0x08,0x00},
{0x49,0x43,0x53,0x46,0x20,0x20,0x20,0x20}
};
struct function_and_rules_block {
unsigned char function_code[2];
unsigned char ulen[2];
unsigned char only_rule[8];
};
static struct function_and_rules_block static_pkd_function_and_rules = {
{0x50,0x44},
{0x0A,0x00},
{'P','K','C','S','-','1','.','2'}
};
static struct function_and_rules_block static_pke_function_and_rules = {
{0x50,0x4B},
{0x0A,0x00},
{'P','K','C','S','-','1','.','2'}
};
struct T6_keyBlock_hdr {
unsigned char blen[2];
unsigned char ulen[2];
unsigned char flags[2];
};
static struct T6_keyBlock_hdr static_T6_keyBlock_hdr = {
{0x89,0x01},
{0x87,0x01},
{0x00}
};
static struct CPRBX static_cprbx = {
0x00DC,
0x02,
{0x00,0x00,0x00},
{0x54,0x32},
{0x00,0x00,0x00,0x00},
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
0x00000000,
{0x00,0x00,0x00,0x00},
0x00000000,
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
0x0000,
0x0000,
0x00000000,
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
0x00,
0x00,
0x0000,
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
};
static struct function_and_rules_block static_pkd_function_and_rulesX_MCL2 = {
{0x50,0x44},
{0x00,0x0A},
{'P','K','C','S','-','1','.','2'}
};
static struct function_and_rules_block static_pke_function_and_rulesX_MCL2 = {
{0x50,0x4B},
{0x00,0x0A},
{'Z','E','R','O','-','P','A','D'}
};
static struct function_and_rules_block static_pkd_function_and_rulesX = {
{0x50,0x44},
{0x00,0x0A},
{'Z','E','R','O','-','P','A','D'}
};
static struct function_and_rules_block static_pke_function_and_rulesX = {
{0x50,0x4B},
{0x00,0x0A},
{'M','R','P',' ',' ',' ',' ',' '}
};
static unsigned char static_PKE_function_code[2] = {0x50, 0x4B};
struct T6_keyBlock_hdrX {
unsigned short blen;
unsigned short ulen;
unsigned char flags[2];
};
static unsigned char static_pad[256] = {
0x1B,0x7B,0x5D,0xB5,0x75,0x01,0x3D,0xFD,0x8D,0xD1,0xC7,0x03,0x2D,0x09,0x23,0x57,
0x89,0x49,0xB9,0x3F,0xBB,0x99,0x41,0x5B,0x75,0x21,0x7B,0x9D,0x3B,0x6B,0x51,0x39,
0xBB,0x0D,0x35,0xB9,0x89,0x0F,0x93,0xA5,0x0B,0x47,0xF1,0xD3,0xBB,0xCB,0xF1,0x9D,
0x23,0x73,0x71,0xFF,0xF3,0xF5,0x45,0xFB,0x61,0x29,0x23,0xFD,0xF1,0x29,0x3F,0x7F,
0x17,0xB7,0x1B,0xA9,0x19,0xBD,0x57,0xA9,0xD7,0x95,0xA3,0xCB,0xED,0x1D,0xDB,0x45,
0x7D,0x11,0xD1,0x51,0x1B,0xED,0x71,0xE9,0xB1,0xD1,0xAB,0xAB,0x21,0x2B,0x1B,0x9F,
0x3B,0x9F,0xF7,0xF7,0xBD,0x63,0xEB,0xAD,0xDF,0xB3,0x6F,0x5B,0xDB,0x8D,0xA9,0x5D,
0xE3,0x7D,0x77,0x49,0x47,0xF5,0xA7,0xFD,0xAB,0x2F,0x27,0x35,0x77,0xD3,0x49,0xC9,
0x09,0xEB,0xB1,0xF9,0xBF,0x4B,0xCB,0x2B,0xEB,0xEB,0x05,0xFF,0x7D,0xC7,0x91,0x8B,
0x09,0x83,0xB9,0xB9,0x69,0x33,0x39,0x6B,0x79,0x75,0x19,0xBF,0xBB,0x07,0x1D,0xBD,
0x29,0xBF,0x39,0x95,0x93,0x1D,0x35,0xC7,0xC9,0x4D,0xE5,0x97,0x0B,0x43,0x9B,0xF1,
0x16,0x93,0x03,0x1F,0xA5,0xFB,0xDB,0xF3,0x27,0x4F,0x27,0x61,0x05,0x1F,0xB9,0x23,
0x2F,0xC3,0x81,0xA9,0x23,0x71,0x55,0x55,0xEB,0xED,0x41,0xE5,0xF3,0x11,0xF1,0x43,
0x69,0x03,0xBD,0x0B,0x37,0x0F,0x51,0x8F,0x0B,0xB5,0x89,0x5B,0x67,0xA9,0xD9,0x4F,
0x01,0xF9,0x21,0x77,0x37,0x73,0x79,0xC5,0x7F,0x51,0xC1,0xCF,0x97,0xA1,0x75,0xAD,
0x35,0x9D,0xD3,0xD3,0xA7,0x9D,0x5D,0x41,0x6F,0x65,0x1B,0xCF,0xA9,0x87,0x91,0x09
};
static struct cca_private_ext_ME static_pvt_me_key = {
{
0x1E,
0x00,
0x0183,
{0x00,0x00,0x00,0x00}
},
{
0x02,
0x00,
0x016C,
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00},
0x00,
0x00,
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00},
{0x80,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00},
{0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00}
},
{
0x04,
0x00,
0x000F,
{0x00,0x00},
0x0003,
0x0000,
0x0000,
{0x01,0x00,0x01}
}
};
static struct cca_public_key static_public_key = {
{
0x1E,
0x00,
0x0000,
{0x00,0x00,0x00,0x00}
},
{
0x04,
0x00,
0x0000,
{0x00,0x00},
0x0000,
0x0000,
0x0000,
{0x01,0x00,0x01}
}
};
#define FIXED_TYPE6_ME_LEN 0x0000025F
#define FIXED_TYPE6_ME_EN_LEN 0x000000F0
#define FIXED_TYPE6_ME_LENX 0x000002CB
#define FIXED_TYPE6_ME_EN_LENX 0x0000015C
static struct cca_public_sec static_cca_pub_sec = {
0x04,
0x00,
0x000f,
{0x00,0x00},
0x0003,
0x0000,
0x0000,
{0x01,0x00,0x01}
};
#define FIXED_TYPE6_CR_LEN 0x00000177
#define FIXED_TYPE6_CR_LENX 0x000001E3
#define MAX_RESPONSE_SIZE 0x00000710
#define MAX_RESPONSEX_SIZE 0x0000077C
#define RESPONSE_CPRB_SIZE 0x000006B8
#define RESPONSE_CPRBX_SIZE 0x00000724
struct type50_hdr {
u8 reserved1;
u8 msg_type_code;
u16 msg_len;
u8 reserved2;
u8 ignored;
u16 reserved3;
};
#define TYPE50_TYPE_CODE 0x50
#define TYPE50_MEB1_LEN (sizeof(struct type50_meb1_msg))
#define TYPE50_MEB2_LEN (sizeof(struct type50_meb2_msg))
#define TYPE50_CRB1_LEN (sizeof(struct type50_crb1_msg))
#define TYPE50_CRB2_LEN (sizeof(struct type50_crb2_msg))
#define TYPE50_MEB1_FMT 0x0001
#define TYPE50_MEB2_FMT 0x0002
#define TYPE50_CRB1_FMT 0x0011
#define TYPE50_CRB2_FMT 0x0012
struct type50_meb1_msg {
struct type50_hdr header;
u16 keyblock_type;
u8 reserved[6];
u8 exponent[128];
u8 modulus[128];
u8 message[128];
};
struct type50_meb2_msg {
struct type50_hdr header;
u16 keyblock_type;
u8 reserved[6];
u8 exponent[256];
u8 modulus[256];
u8 message[256];
};
struct type50_crb1_msg {
struct type50_hdr header;
u16 keyblock_type;
u8 reserved[6];
u8 p[64];
u8 q[64];
u8 dp[64];
u8 dq[64];
u8 u[64];
u8 message[128];
};
struct type50_crb2_msg {
struct type50_hdr header;
u16 keyblock_type;
u8 reserved[6];
u8 p[128];
u8 q[128];
u8 dp[128];
u8 dq[128];
u8 u[128];
u8 message[256];
};
union type50_msg {
struct type50_meb1_msg meb1;
struct type50_meb2_msg meb2;
struct type50_crb1_msg crb1;
struct type50_crb2_msg crb2;
};
struct type80_hdr {
u8 reserved1;
u8 type;
u16 len;
u8 code;
u8 reserved2[3];
u8 reserved3[8];
};
#define TYPE80_RSP_CODE 0x80
struct error_hdr {
unsigned char reserved1;
unsigned char type;
unsigned char reserved2[2];
unsigned char reply_code;
unsigned char reserved3[3];
};
#define TYPE82_RSP_CODE 0x82
#define TYPE88_RSP_CODE 0x88
#define REP82_ERROR_MACHINE_FAILURE 0x10
#define REP82_ERROR_PREEMPT_FAILURE 0x12
#define REP82_ERROR_CHECKPT_FAILURE 0x14
#define REP82_ERROR_MESSAGE_TYPE 0x20
#define REP82_ERROR_INVALID_COMM_CD 0x21
#define REP82_ERROR_INVALID_MSG_LEN 0x23
#define REP82_ERROR_RESERVD_FIELD 0x24
#define REP82_ERROR_FORMAT_FIELD 0x29
#define REP82_ERROR_INVALID_COMMAND 0x30
#define REP82_ERROR_MALFORMED_MSG 0x40
#define REP82_ERROR_RESERVED_FIELDO 0x50
#define REP82_ERROR_WORD_ALIGNMENT 0x60
#define REP82_ERROR_MESSAGE_LENGTH 0x80
#define REP82_ERROR_OPERAND_INVALID 0x82
#define REP82_ERROR_OPERAND_SIZE 0x84
#define REP82_ERROR_EVEN_MOD_IN_OPND 0x85
#define REP82_ERROR_RESERVED_FIELD 0x88
#define REP82_ERROR_TRANSPORT_FAIL 0x90
#define REP82_ERROR_PACKET_TRUNCATED 0xA0
#define REP82_ERROR_ZERO_BUFFER_LEN 0xB0
#define REP88_ERROR_MODULE_FAILURE 0x10
#define REP88_ERROR_MODULE_TIMEOUT 0x11
#define REP88_ERROR_MODULE_NOTINIT 0x13
#define REP88_ERROR_MODULE_NOTAVAIL 0x14
#define REP88_ERROR_MODULE_DISABLED 0x15
#define REP88_ERROR_MODULE_IN_DIAGN 0x17
#define REP88_ERROR_FASTPATH_DISABLD 0x19
#define REP88_ERROR_MESSAGE_TYPE 0x20
#define REP88_ERROR_MESSAGE_MALFORMD 0x22
#define REP88_ERROR_MESSAGE_LENGTH 0x23
#define REP88_ERROR_RESERVED_FIELD 0x24
#define REP88_ERROR_KEY_TYPE 0x34
#define REP88_ERROR_INVALID_KEY 0x82
#define REP88_ERROR_OPERAND 0x84
#define REP88_ERROR_OPERAND_EVEN_MOD 0x85
#define CALLER_HEADER 12
static inline int
testq(int q_nr, int *q_depth, int *dev_type, struct ap_status_word *stat)
{
int ccode;
asm volatile
#ifdef CONFIG_64BIT
(" llgfr 0,%4 \n"
" slgr 1,1 \n"
" lgr 2,1 \n"
"0: .long 0xb2af0000 \n"
"1: ipm %0 \n"
" srl %0,28 \n"
" iihh %0,0 \n"
" iihl %0,0 \n"
" lgr %1,1 \n"
" lgr %3,2 \n"
" srl %3,24 \n"
" sll 2,24 \n"
" srl 2,24 \n"
" lgr %2,2 \n"
"2: \n"
".section .fixup,\"ax\" \n"
"3: \n"
" lhi %0,%h5 \n"
" jg 2b \n"
".previous \n"
".section __ex_table,\"a\" \n"
" .align 8 \n"
" .quad 0b,3b \n"
" .quad 1b,3b \n"
".previous"
:"=d" (ccode),"=d" (*stat),"=d" (*q_depth), "=d" (*dev_type)
:"d" (q_nr), "K" (DEV_TSQ_EXCEPTION)
:"cc","0","1","2","memory");
#else
(" lr 0,%4 \n"
" slr 1,1 \n"
" lr 2,1 \n"
"0: .long 0xb2af0000 \n"
"1: ipm %0 \n"
" srl %0,28 \n"
" lr %1,1 \n"
" lr %3,2 \n"
" srl %3,24 \n"
" sll 2,24 \n"
" srl 2,24 \n"
" lr %2,2 \n"
"2: \n"
".section .fixup,\"ax\" \n"
"3: \n"
" lhi %0,%h5 \n"
" bras 1,4f \n"
" .long 2b \n"
"4: \n"
" l 1,0(1) \n"
" br 1 \n"
".previous \n"
".section __ex_table,\"a\" \n"
" .align 4 \n"
" .long 0b,3b \n"
" .long 1b,3b \n"
".previous"
:"=d" (ccode),"=d" (*stat),"=d" (*q_depth), "=d" (*dev_type)
:"d" (q_nr), "K" (DEV_TSQ_EXCEPTION)
:"cc","0","1","2","memory");
#endif
return ccode;
}
static inline int
resetq(int q_nr, struct ap_status_word *stat_p)
{
int ccode;
asm volatile
#ifdef CONFIG_64BIT
(" llgfr 0,%2 \n"
" lghi 1,1 \n"
" sll 1,24 \n"
" or 0,1 \n"
" slgr 1,1 \n"
" lgr 2,1 \n"
"0: .long 0xb2af0000 \n"
"1: ipm %0 \n"
" srl %0,28 \n"
" iihh %0,0 \n"
" iihl %0,0 \n"
" lgr %1,1 \n"
"2: \n"
".section .fixup,\"ax\" \n"
"3: \n"
" lhi %0,%h3 \n"
" jg 2b \n"
".previous \n"
".section __ex_table,\"a\" \n"
" .align 8 \n"
" .quad 0b,3b \n"
" .quad 1b,3b \n"
".previous"
:"=d" (ccode),"=d" (*stat_p)
:"d" (q_nr), "K" (DEV_RSQ_EXCEPTION)
:"cc","0","1","2","memory");
#else
(" lr 0,%2 \n"
" lhi 1,1 \n"
" sll 1,24 \n"
" or 0,1 \n"
" slr 1,1 \n"
" lr 2,1 \n"
"0: .long 0xb2af0000 \n"
"1: ipm %0 \n"
" srl %0,28 \n"
" lr %1,1 \n"
"2: \n"
".section .fixup,\"ax\" \n"
"3: \n"
" lhi %0,%h3 \n"
" bras 1,4f \n"
" .long 2b \n"
"4: \n"
" l 1,0(1) \n"
" br 1 \n"
".previous \n"
".section __ex_table,\"a\" \n"
" .align 4 \n"
" .long 0b,3b \n"
" .long 1b,3b \n"
".previous"
:"=d" (ccode),"=d" (*stat_p)
:"d" (q_nr), "K" (DEV_RSQ_EXCEPTION)
:"cc","0","1","2","memory");
#endif
return ccode;
}
static inline int
sen(int msg_len, unsigned char *msg_ext, struct ap_status_word *stat)
{
int ccode;
asm volatile
#ifdef CONFIG_64BIT
(" lgr 6,%3 \n"
" llgfr 7,%2 \n"
" llgt 0,0(6) \n"
" lghi 1,64 \n"
" sll 1,24 \n"
" or 0,1 \n"
" la 6,4(6) \n"
" llgt 2,0(6) \n"
" llgt 3,4(6) \n"
" la 6,8(6) \n"
" slr 1,1 \n"
"0: .long 0xb2ad0026 \n"
"1: brc 2,0b \n"
" ipm %0 \n"
" srl %0,28 \n"
" iihh %0,0 \n"
" iihl %0,0 \n"
" lgr %1,1 \n"
"2: \n"
".section .fixup,\"ax\" \n"
"3: \n"
" lhi %0,%h4 \n"
" jg 2b \n"
".previous \n"
".section __ex_table,\"a\" \n"
" .align 8 \n"
" .quad 0b,3b \n"
" .quad 1b,3b \n"
".previous"
:"=d" (ccode),"=d" (*stat)
:"d" (msg_len),"a" (msg_ext), "K" (DEV_SEN_EXCEPTION)
:"cc","0","1","2","3","6","7","memory");
#else
(" lr 6,%3 \n"
" lr 7,%2 \n"
" l 0,0(6) \n"
" lhi 1,64 \n"
" sll 1,24 \n"
" or 0,1 \n"
" la 6,4(6) \n"
" l 2,0(6) \n"
" l 3,4(6) \n"
" la 6,8(6) \n"
" slr 1,1 \n"
"0: .long 0xb2ad0026 \n"
"1: brc 2,0b \n"
" ipm %0 \n"
" srl %0,28 \n"
" lr %1,1 \n"
"2: \n"
".section .fixup,\"ax\" \n"
"3: \n"
" lhi %0,%h4 \n"
" bras 1,4f \n"
" .long 2b \n"
"4: \n"
" l 1,0(1) \n"
" br 1 \n"
".previous \n"
".section __ex_table,\"a\" \n"
" .align 4 \n"
" .long 0b,3b \n"
" .long 1b,3b \n"
".previous"
:"=d" (ccode),"=d" (*stat)
:"d" (msg_len),"a" (msg_ext), "K" (DEV_SEN_EXCEPTION)
:"cc","0","1","2","3","6","7","memory");
#endif
return ccode;
}
static inline int
rec(int q_nr, int buff_l, unsigned char *rsp, unsigned char *id,
struct ap_status_word *st)
{
int ccode;
asm volatile
#ifdef CONFIG_64BIT
(" llgfr 0,%2 \n"
" lgr 3,%4 \n"
" lgr 6,%3 \n"
" llgfr 7,%5 \n"
" lghi 1,128 \n"
" sll 1,24 \n"
" or 0,1 \n"
" slgr 1,1 \n"
" lgr 2,1 \n"
" lgr 4,1 \n"
" lgr 5,1 \n"
"0: .long 0xb2ae0046 \n"
"1: brc 2,0b \n"
" brc 4,0b \n"
" ipm %0 \n"
" srl %0,28 \n"
" iihh %0,0 \n"
" iihl %0,0 \n"
" lgr %1,1 \n"
" st 4,0(3) \n"
" st 5,4(3) \n"
"2: \n"
".section .fixup,\"ax\" \n"
"3: \n"
" lhi %0,%h6 \n"
" jg 2b \n"
".previous \n"
".section __ex_table,\"a\" \n"
" .align 8 \n"
" .quad 0b,3b \n"
" .quad 1b,3b \n"
".previous"
:"=d"(ccode),"=d"(*st)
:"d" (q_nr), "d" (rsp), "d" (id), "d" (buff_l), "K" (DEV_REC_EXCEPTION)
:"cc","0","1","2","3","4","5","6","7","memory");
#else
(" lr 0,%2 \n"
" lr 3,%4 \n"
" lr 6,%3 \n"
" lr 7,%5 \n"
" lhi 1,128 \n"
" sll 1,24 \n"
" or 0,1 \n"
" slr 1,1 \n"
" lr 2,1 \n"
" lr 4,1 \n"
" lr 5,1 \n"
"0: .long 0xb2ae0046 \n"
"1: brc 2,0b \n"
" brc 4,0b \n"
" ipm %0 \n"
" srl %0,28 \n"
" lr %1,1 \n"
" st 4,0(3) \n"
" st 5,4(3) \n"
"2: \n"
".section .fixup,\"ax\" \n"
"3: \n"
" lhi %0,%h6 \n"
" bras 1,4f \n"
" .long 2b \n"
"4: \n"
" l 1,0(1) \n"
" br 1 \n"
".previous \n"
".section __ex_table,\"a\" \n"
" .align 4 \n"
" .long 0b,3b \n"
" .long 1b,3b \n"
".previous"
:"=d"(ccode),"=d"(*st)
:"d" (q_nr), "d" (rsp), "d" (id), "d" (buff_l), "K" (DEV_REC_EXCEPTION)
:"cc","0","1","2","3","4","5","6","7","memory");
#endif
return ccode;
}
static inline void
itoLe2(int *i_p, unsigned char *lechars)
{
*lechars = *((unsigned char *) i_p + sizeof(int) - 1);
*(lechars + 1) = *((unsigned char *) i_p + sizeof(int) - 2);
}
static inline void
le2toI(unsigned char *lechars, int *i_p)
{
unsigned char *ic_p;
*i_p = 0;
ic_p = (unsigned char *) i_p;
*(ic_p + 2) = *(lechars + 1);
*(ic_p + 3) = *(lechars);
}
static inline int
is_empty(unsigned char *ptr, int len)
{
return !memcmp(ptr, (unsigned char *) &static_pvt_me_key+60, len);
}
enum hdstat
query_online(int deviceNr, int cdx, int resetNr, int *q_depth, int *dev_type)
{
int q_nr, i, t_depth, t_dev_type;
enum devstat ccode;
struct ap_status_word stat_word;
enum hdstat stat;
int break_out;
q_nr = (deviceNr << SKIP_BITL) + cdx;
stat = HD_BUSY;
ccode = testq(q_nr, &t_depth, &t_dev_type, &stat_word);
PDEBUG("ccode %d response_code %02X\n", ccode, stat_word.response_code);
break_out = 0;
for (i = 0; i < resetNr; i++) {
if (ccode > 3) {
PRINTKC("Exception testing device %d\n", i);
return HD_TSQ_EXCEPTION;
}
switch (ccode) {
case 0:
PDEBUG("t_dev_type %d\n", t_dev_type);
break_out = 1;
stat = HD_ONLINE;
*q_depth = t_depth + 1;
switch (t_dev_type) {
case PCICA_HW:
*dev_type = PCICA;
break;
case PCICC_HW:
*dev_type = PCICC;
break;
case PCIXCC_HW:
*dev_type = PCIXCC_UNK;
break;
case CEX2C_HW:
*dev_type = CEX2C;
break;
case CEX2A_HW:
*dev_type = CEX2A;
break;
default:
*dev_type = NILDEV;
break;
}
PDEBUG("available device %d: Q depth = %d, dev "
"type = %d, stat = %02X%02X%02X%02X\n",
deviceNr, *q_depth, *dev_type,
stat_word.q_stat_flags,
stat_word.response_code,
stat_word.reserved[0],
stat_word.reserved[1]);
break;
case 3:
switch (stat_word.response_code) {
case AP_RESPONSE_NORMAL:
stat = HD_ONLINE;
break_out = 1;
*q_depth = t_depth + 1;
*dev_type = t_dev_type;
PDEBUG("cc3, available device "
"%d: Q depth = %d, dev "
"type = %d, stat = "
"%02X%02X%02X%02X\n",
deviceNr, *q_depth,
*dev_type,
stat_word.q_stat_flags,
stat_word.response_code,
stat_word.reserved[0],
stat_word.reserved[1]);
break;
case AP_RESPONSE_Q_NOT_AVAIL:
stat = HD_NOT_THERE;
break_out = 1;
break;
case AP_RESPONSE_RESET_IN_PROGRESS:
PDEBUG("device %d in reset\n",
deviceNr);
break;
case AP_RESPONSE_DECONFIGURED:
stat = HD_DECONFIGURED;
break_out = 1;
break;
case AP_RESPONSE_CHECKSTOPPED:
stat = HD_CHECKSTOPPED;
break_out = 1;
break;
case AP_RESPONSE_BUSY:
PDEBUG("device %d busy\n",
deviceNr);
break;
default:
break;
}
break;
default:
stat = HD_NOT_THERE;
break_out = 1;
break;
}
if (break_out)
break;
udelay(5);
ccode = testq(q_nr, &t_depth, &t_dev_type, &stat_word);
}
return stat;
}
enum devstat
reset_device(int deviceNr, int cdx, int resetNr)
{
int q_nr, ccode = 0, dummy_qdepth, dummy_devType, i;
struct ap_status_word stat_word;
enum devstat stat;
int break_out;
q_nr = (deviceNr << SKIP_BITL) + cdx;
stat = DEV_GONE;
ccode = resetq(q_nr, &stat_word);
if (ccode > 3)
return DEV_RSQ_EXCEPTION;
break_out = 0;
for (i = 0; i < resetNr; i++) {
switch (ccode) {
case 0:
stat = DEV_ONLINE;
if (stat_word.q_stat_flags & AP_Q_STATUS_EMPTY)
break_out = 1;
break;
case 3:
switch (stat_word.response_code) {
case AP_RESPONSE_NORMAL:
stat = DEV_ONLINE;
if (stat_word.q_stat_flags & AP_Q_STATUS_EMPTY)
break_out = 1;
break;
case AP_RESPONSE_Q_NOT_AVAIL:
case AP_RESPONSE_DECONFIGURED:
case AP_RESPONSE_CHECKSTOPPED:
stat = DEV_GONE;
break_out = 1;
break;
case AP_RESPONSE_RESET_IN_PROGRESS:
case AP_RESPONSE_BUSY:
default:
break;
}
break;
default:
stat = DEV_GONE;
break_out = 1;
break;
}
if (break_out == 1)
break;
udelay(5);
ccode = testq(q_nr, &dummy_qdepth, &dummy_devType, &stat_word);
if (ccode > 3) {
stat = DEV_TSQ_EXCEPTION;
break;
}
}
PDEBUG("Number of testq's needed for reset: %d\n", i);
if (i >= resetNr) {
stat = DEV_GONE;
}
return stat;
}
#ifdef DEBUG_HYDRA_MSGS
static inline void
print_buffer(unsigned char *buffer, int bufflen)
{
int i;
for (i = 0; i < bufflen; i += 16) {
PRINTK("%04X: %02X%02X%02X%02X %02X%02X%02X%02X "
"%02X%02X%02X%02X %02X%02X%02X%02X\n", i,
buffer[i+0], buffer[i+1], buffer[i+2], buffer[i+3],
buffer[i+4], buffer[i+5], buffer[i+6], buffer[i+7],
buffer[i+8], buffer[i+9], buffer[i+10], buffer[i+11],
buffer[i+12], buffer[i+13], buffer[i+14], buffer[i+15]);
}
}
#endif
enum devstat
send_to_AP(int dev_nr, int cdx, int msg_len, unsigned char *msg_ext)
{
struct ap_status_word stat_word;
enum devstat stat;
int ccode;
u32 *q_nr_p = (u32 *)msg_ext;
*q_nr_p = (dev_nr << SKIP_BITL) + cdx;
PDEBUG("msg_len passed to sen: %d\n", msg_len);
PDEBUG("q number passed to sen: %02x%02x%02x%02x\n",
msg_ext[0], msg_ext[1], msg_ext[2], msg_ext[3]);
stat = DEV_GONE;
#ifdef DEBUG_HYDRA_MSGS
PRINTK("Request header: %02X%02X%02X%02X %02X%02X%02X%02X "
"%02X%02X%02X%02X\n",
msg_ext[0], msg_ext[1], msg_ext[2], msg_ext[3],
msg_ext[4], msg_ext[5], msg_ext[6], msg_ext[7],
msg_ext[8], msg_ext[9], msg_ext[10], msg_ext[11]);
print_buffer(msg_ext+CALLER_HEADER, msg_len);
#endif
ccode = sen(msg_len, msg_ext, &stat_word);
if (ccode > 3)
return DEV_SEN_EXCEPTION;
PDEBUG("nq cc: %u, st: %02x%02x%02x%02x\n",
ccode, stat_word.q_stat_flags, stat_word.response_code,
stat_word.reserved[0], stat_word.reserved[1]);
switch (ccode) {
case 0:
stat = DEV_ONLINE;
break;
case 1:
stat = DEV_GONE;
break;
case 3:
switch (stat_word.response_code) {
case AP_RESPONSE_NORMAL:
stat = DEV_ONLINE;
break;
case AP_RESPONSE_Q_FULL:
stat = DEV_QUEUE_FULL;
break;
default:
stat = DEV_GONE;
break;
}
break;
default:
stat = DEV_GONE;
break;
}
return stat;
}
enum devstat
receive_from_AP(int dev_nr, int cdx, int resplen, unsigned char *resp,
unsigned char *psmid)
{
int ccode;
struct ap_status_word stat_word;
enum devstat stat;
memset(resp, 0x00, 8);
ccode = rec((dev_nr << SKIP_BITL) + cdx, resplen, resp, psmid,
&stat_word);
if (ccode > 3)
return DEV_REC_EXCEPTION;
PDEBUG("dq cc: %u, st: %02x%02x%02x%02x\n",
ccode, stat_word.q_stat_flags, stat_word.response_code,
stat_word.reserved[0], stat_word.reserved[1]);
stat = DEV_GONE;
switch (ccode) {
case 0:
stat = DEV_ONLINE;
#ifdef DEBUG_HYDRA_MSGS
print_buffer(resp, resplen);
#endif
break;
case 3:
switch (stat_word.response_code) {
case AP_RESPONSE_NORMAL:
stat = DEV_ONLINE;
break;
case AP_RESPONSE_NO_PENDING_REPLY:
if (stat_word.q_stat_flags & AP_Q_STATUS_EMPTY)
stat = DEV_EMPTY;
else
stat = DEV_NO_WORK;
break;
case AP_RESPONSE_INDEX_TOO_BIG:
case AP_RESPONSE_NO_FIRST_PART:
case AP_RESPONSE_MESSAGE_TOO_BIG:
stat = DEV_BAD_MESSAGE;
break;
default:
break;
}
break;
default:
break;
}
return stat;
}
static inline int
pad_msg(unsigned char *buffer, int totalLength, int msgLength)
{
int pad_len;
for (pad_len = 0; pad_len < (totalLength - msgLength); pad_len++)
if (buffer[pad_len] != 0x00)
break;
pad_len -= 3;
if (pad_len < 8)
return SEN_PAD_ERROR;
buffer[0] = 0x00;
buffer[1] = 0x02;
memcpy(buffer+2, static_pad, pad_len);
buffer[pad_len + 2] = 0x00;
return 0;
}
static inline int
is_common_public_key(unsigned char *key, int len)
{
int i;
for (i = 0; i < len; i++)
if (key[i])
break;
key += i;
len -= i;
if (((len == 1) && (key[0] == 3)) ||
((len == 3) && (key[0] == 1) && (key[1] == 0) && (key[2] == 1)))
return 1;
return 0;
}
static int
ICAMEX_msg_to_type4MEX_msg(struct ica_rsa_modexpo *icaMex_p, int *z90cMsg_l_p,
union type4_msg *z90cMsg_p)
{
int mod_len, msg_size, mod_tgt_len, exp_tgt_len, inp_tgt_len;
unsigned char *mod_tgt, *exp_tgt, *inp_tgt;
union type4_msg *tmp_type4_msg;
mod_len = icaMex_p->inputdatalength;
msg_size = ((mod_len <= 128) ? TYPE4_SME_LEN : TYPE4_LME_LEN) +
CALLER_HEADER;
memset(z90cMsg_p, 0, msg_size);
tmp_type4_msg = (union type4_msg *)
((unsigned char *) z90cMsg_p + CALLER_HEADER);
tmp_type4_msg->sme.header.msg_type_code = TYPE4_TYPE_CODE;
tmp_type4_msg->sme.header.request_code = TYPE4_REQU_CODE;
if (mod_len <= 128) {
tmp_type4_msg->sme.header.msg_fmt = TYPE4_SME_FMT;
tmp_type4_msg->sme.header.msg_len = TYPE4_SME_LEN;
mod_tgt = tmp_type4_msg->sme.modulus;
mod_tgt_len = sizeof(tmp_type4_msg->sme.modulus);
exp_tgt = tmp_type4_msg->sme.exponent;
exp_tgt_len = sizeof(tmp_type4_msg->sme.exponent);
inp_tgt = tmp_type4_msg->sme.message;
inp_tgt_len = sizeof(tmp_type4_msg->sme.message);
} else {
tmp_type4_msg->lme.header.msg_fmt = TYPE4_LME_FMT;
tmp_type4_msg->lme.header.msg_len = TYPE4_LME_LEN;
mod_tgt = tmp_type4_msg->lme.modulus;
mod_tgt_len = sizeof(tmp_type4_msg->lme.modulus);
exp_tgt = tmp_type4_msg->lme.exponent;
exp_tgt_len = sizeof(tmp_type4_msg->lme.exponent);
inp_tgt = tmp_type4_msg->lme.message;
inp_tgt_len = sizeof(tmp_type4_msg->lme.message);
}
mod_tgt += (mod_tgt_len - mod_len);
if (copy_from_user(mod_tgt, icaMex_p->n_modulus, mod_len))
return SEN_RELEASED;
if (is_empty(mod_tgt, mod_len))
return SEN_USER_ERROR;
exp_tgt += (exp_tgt_len - mod_len);
if (copy_from_user(exp_tgt, icaMex_p->b_key, mod_len))
return SEN_RELEASED;
if (is_empty(exp_tgt, mod_len))
return SEN_USER_ERROR;
inp_tgt += (inp_tgt_len - mod_len);
if (copy_from_user(inp_tgt, icaMex_p->inputdata, mod_len))
return SEN_RELEASED;
if (is_empty(inp_tgt, mod_len))
return SEN_USER_ERROR;
*z90cMsg_l_p = msg_size - CALLER_HEADER;
return 0;
}
static int
ICACRT_msg_to_type4CRT_msg(struct ica_rsa_modexpo_crt *icaMsg_p,
int *z90cMsg_l_p, union type4_msg *z90cMsg_p)
{
int mod_len, short_len, long_len, tmp_size, p_tgt_len, q_tgt_len,
dp_tgt_len, dq_tgt_len, u_tgt_len, inp_tgt_len;
unsigned char *p_tgt, *q_tgt, *dp_tgt, *dq_tgt, *u_tgt, *inp_tgt;
union type4_msg *tmp_type4_msg;
mod_len = icaMsg_p->inputdatalength;
short_len = mod_len / 2;
long_len = mod_len / 2 + 8;
tmp_size = ((mod_len <= 128) ? TYPE4_SCR_LEN : TYPE4_LCR_LEN) +
CALLER_HEADER;
memset(z90cMsg_p, 0, tmp_size);
tmp_type4_msg = (union type4_msg *)
((unsigned char *) z90cMsg_p + CALLER_HEADER);
tmp_type4_msg->scr.header.msg_type_code = TYPE4_TYPE_CODE;
tmp_type4_msg->scr.header.request_code = TYPE4_REQU_CODE;
if (mod_len <= 128) {
tmp_type4_msg->scr.header.msg_fmt = TYPE4_SCR_FMT;
tmp_type4_msg->scr.header.msg_len = TYPE4_SCR_LEN;
p_tgt = tmp_type4_msg->scr.p;
p_tgt_len = sizeof(tmp_type4_msg->scr.p);
q_tgt = tmp_type4_msg->scr.q;
q_tgt_len = sizeof(tmp_type4_msg->scr.q);
dp_tgt = tmp_type4_msg->scr.dp;
dp_tgt_len = sizeof(tmp_type4_msg->scr.dp);
dq_tgt = tmp_type4_msg->scr.dq;
dq_tgt_len = sizeof(tmp_type4_msg->scr.dq);
u_tgt = tmp_type4_msg->scr.u;
u_tgt_len = sizeof(tmp_type4_msg->scr.u);
inp_tgt = tmp_type4_msg->scr.message;
inp_tgt_len = sizeof(tmp_type4_msg->scr.message);
} else {
tmp_type4_msg->lcr.header.msg_fmt = TYPE4_LCR_FMT;
tmp_type4_msg->lcr.header.msg_len = TYPE4_LCR_LEN;
p_tgt = tmp_type4_msg->lcr.p;
p_tgt_len = sizeof(tmp_type4_msg->lcr.p);
q_tgt = tmp_type4_msg->lcr.q;
q_tgt_len = sizeof(tmp_type4_msg->lcr.q);
dp_tgt = tmp_type4_msg->lcr.dp;
dp_tgt_len = sizeof(tmp_type4_msg->lcr.dp);
dq_tgt = tmp_type4_msg->lcr.dq;
dq_tgt_len = sizeof(tmp_type4_msg->lcr.dq);
u_tgt = tmp_type4_msg->lcr.u;
u_tgt_len = sizeof(tmp_type4_msg->lcr.u);
inp_tgt = tmp_type4_msg->lcr.message;
inp_tgt_len = sizeof(tmp_type4_msg->lcr.message);
}
p_tgt += (p_tgt_len - long_len);
if (copy_from_user(p_tgt, icaMsg_p->np_prime, long_len))
return SEN_RELEASED;
if (is_empty(p_tgt, long_len))
return SEN_USER_ERROR;
q_tgt += (q_tgt_len - short_len);
if (copy_from_user(q_tgt, icaMsg_p->nq_prime, short_len))
return SEN_RELEASED;
if (is_empty(q_tgt, short_len))
return SEN_USER_ERROR;
dp_tgt += (dp_tgt_len - long_len);
if (copy_from_user(dp_tgt, icaMsg_p->bp_key, long_len))
return SEN_RELEASED;
if (is_empty(dp_tgt, long_len))
return SEN_USER_ERROR;
dq_tgt += (dq_tgt_len - short_len);
if (copy_from_user(dq_tgt, icaMsg_p->bq_key, short_len))
return SEN_RELEASED;
if (is_empty(dq_tgt, short_len))
return SEN_USER_ERROR;
u_tgt += (u_tgt_len - long_len);
if (copy_from_user(u_tgt, icaMsg_p->u_mult_inv, long_len))
return SEN_RELEASED;
if (is_empty(u_tgt, long_len))
return SEN_USER_ERROR;
inp_tgt += (inp_tgt_len - mod_len);
if (copy_from_user(inp_tgt, icaMsg_p->inputdata, mod_len))
return SEN_RELEASED;
if (is_empty(inp_tgt, mod_len))
return SEN_USER_ERROR;
*z90cMsg_l_p = tmp_size - CALLER_HEADER;
return 0;
}
static int
ICAMEX_msg_to_type6MEX_de_msg(struct ica_rsa_modexpo *icaMsg_p, int cdx,
int *z90cMsg_l_p, struct type6_msg *z90cMsg_p)
{
int mod_len, vud_len, tmp_size, total_CPRB_len, parmBlock_l;
unsigned char *temp;
struct type6_hdr *tp6Hdr_p;
struct CPRB *cprb_p;
struct cca_private_ext_ME *key_p;
static int deprecated_msg_count = 0;
mod_len = icaMsg_p->inputdatalength;
tmp_size = FIXED_TYPE6_ME_LEN + mod_len;
total_CPRB_len = tmp_size - sizeof(struct type6_hdr);
parmBlock_l = total_CPRB_len - sizeof(struct CPRB);
tmp_size = 4*((tmp_size + 3)/4) + CALLER_HEADER;
memset(z90cMsg_p, 0, tmp_size);
temp = (unsigned char *)z90cMsg_p + CALLER_HEADER;
memcpy(temp, &static_type6_hdr, sizeof(struct type6_hdr));
tp6Hdr_p = (struct type6_hdr *)temp;
tp6Hdr_p->ToCardLen1 = 4*((total_CPRB_len+3)/4);
tp6Hdr_p->FromCardLen1 = RESPONSE_CPRB_SIZE;
temp += sizeof(struct type6_hdr);
memcpy(temp, &static_cprb, sizeof(struct CPRB));
cprb_p = (struct CPRB *) temp;
cprb_p->usage_domain[0]= (unsigned char)cdx;
itoLe2(&parmBlock_l, cprb_p->req_parml);
itoLe2((int *)&(tp6Hdr_p->FromCardLen1), cprb_p->rpl_parml);
temp += sizeof(struct CPRB);
memcpy(temp, &static_pkd_function_and_rules,
sizeof(struct function_and_rules_block));
temp += sizeof(struct function_and_rules_block);
vud_len = 2 + icaMsg_p->inputdatalength;
itoLe2(&vud_len, temp);
temp += 2;
if (copy_from_user(temp, icaMsg_p->inputdata, mod_len))
return SEN_RELEASED;
if (is_empty(temp, mod_len))
return SEN_USER_ERROR;
temp += mod_len;
memcpy(temp, &static_T6_keyBlock_hdr, sizeof(struct T6_keyBlock_hdr));
temp += sizeof(struct T6_keyBlock_hdr);
memcpy(temp, &static_pvt_me_key, sizeof(struct cca_private_ext_ME));
key_p = (struct cca_private_ext_ME *)temp;
temp = key_p->pvtMESec.exponent + sizeof(key_p->pvtMESec.exponent)
- mod_len;
if (copy_from_user(temp, icaMsg_p->b_key, mod_len))
return SEN_RELEASED;
if (is_empty(temp, mod_len))
return SEN_USER_ERROR;
if (is_common_public_key(temp, mod_len)) {
if (deprecated_msg_count < 20) {
PRINTK("Common public key used for modex decrypt\n");
deprecated_msg_count++;
if (deprecated_msg_count == 20)
PRINTK("No longer issuing messages about common"
" public key for modex decrypt.\n");
}
return SEN_NOT_AVAIL;
}
temp = key_p->pvtMESec.modulus + sizeof(key_p->pvtMESec.modulus)
- mod_len;
if (copy_from_user(temp, icaMsg_p->n_modulus, mod_len))
return SEN_RELEASED;
if (is_empty(temp, mod_len))
return SEN_USER_ERROR;
key_p->pubMESec.modulus_bit_len = 8 * mod_len;
*z90cMsg_l_p = tmp_size - CALLER_HEADER;
return 0;
}
static int
ICAMEX_msg_to_type6MEX_en_msg(struct ica_rsa_modexpo *icaMsg_p, int cdx,
int *z90cMsg_l_p, struct type6_msg *z90cMsg_p)
{
int mod_len, vud_len, exp_len, key_len;
int pad_len, tmp_size, total_CPRB_len, parmBlock_l, i;
unsigned char *temp_exp, *exp_p, *temp;
struct type6_hdr *tp6Hdr_p;
struct CPRB *cprb_p;
struct cca_public_key *key_p;
struct T6_keyBlock_hdr *keyb_p;
temp_exp = kmalloc(256, GFP_KERNEL);
if (!temp_exp)
return EGETBUFF;
mod_len = icaMsg_p->inputdatalength;
if (copy_from_user(temp_exp, icaMsg_p->b_key, mod_len)) {
kfree(temp_exp);
return SEN_RELEASED;
}
if (is_empty(temp_exp, mod_len)) {
kfree(temp_exp);
return SEN_USER_ERROR;
}
exp_p = temp_exp;
for (i = 0; i < mod_len; i++)
if (exp_p[i])
break;
if (i >= mod_len) {
kfree(temp_exp);
return SEN_USER_ERROR;
}
exp_len = mod_len - i;
exp_p += i;
PDEBUG("exp_len after computation: %08x\n", exp_len);
tmp_size = FIXED_TYPE6_ME_EN_LEN + 2 * mod_len + exp_len;
total_CPRB_len = tmp_size - sizeof(struct type6_hdr);
parmBlock_l = total_CPRB_len - sizeof(struct CPRB);
tmp_size = 4*((tmp_size + 3)/4) + CALLER_HEADER;
vud_len = 2 + mod_len;
memset(z90cMsg_p, 0, tmp_size);
temp = (unsigned char *)z90cMsg_p + CALLER_HEADER;
memcpy(temp, &static_type6_hdr, sizeof(struct type6_hdr));
tp6Hdr_p = (struct type6_hdr *)temp;
tp6Hdr_p->ToCardLen1 = 4*((total_CPRB_len+3)/4);
tp6Hdr_p->FromCardLen1 = RESPONSE_CPRB_SIZE;
memcpy(tp6Hdr_p->function_code, static_PKE_function_code,
sizeof(static_PKE_function_code));
temp += sizeof(struct type6_hdr);
memcpy(temp, &static_cprb, sizeof(struct CPRB));
cprb_p = (struct CPRB *) temp;
cprb_p->usage_domain[0]= (unsigned char)cdx;
itoLe2((int *)&(tp6Hdr_p->FromCardLen1), cprb_p->rpl_parml);
temp += sizeof(struct CPRB);
memcpy(temp, &static_pke_function_and_rules,
sizeof(struct function_and_rules_block));
temp += sizeof(struct function_and_rules_block);
temp += 2;
if (copy_from_user(temp, icaMsg_p->inputdata, mod_len)) {
kfree(temp_exp);
return SEN_RELEASED;
}
if (is_empty(temp, mod_len)) {
kfree(temp_exp);
return SEN_USER_ERROR;
}
if ((temp[0] != 0x00) || (temp[1] != 0x02)) {
kfree(temp_exp);
return SEN_NOT_AVAIL;
}
for (i = 2; i < mod_len; i++)
if (temp[i] == 0x00)
break;
if ((i < 9) || (i > (mod_len - 2))) {
kfree(temp_exp);
return SEN_NOT_AVAIL;
}
pad_len = i + 1;
vud_len = mod_len - pad_len;
memmove(temp, temp+pad_len, vud_len);
temp -= 2;
vud_len += 2;
itoLe2(&vud_len, temp);
temp += (vud_len);
keyb_p = (struct T6_keyBlock_hdr *)temp;
temp += sizeof(struct T6_keyBlock_hdr);
memcpy(temp, &static_public_key, sizeof(static_public_key));
key_p = (struct cca_public_key *)temp;
temp = key_p->pubSec.exponent;
memcpy(temp, exp_p, exp_len);
kfree(temp_exp);
temp += exp_len;
if (copy_from_user(temp, icaMsg_p->n_modulus, mod_len))
return SEN_RELEASED;
if (is_empty(temp, mod_len))
return SEN_USER_ERROR;
key_p->pubSec.modulus_bit_len = 8 * mod_len;
key_p->pubSec.modulus_byte_len = mod_len;
key_p->pubSec.exponent_len = exp_len;
key_p->pubSec.section_length = CALLER_HEADER + mod_len + exp_len;
key_len = key_p->pubSec.section_length + sizeof(struct cca_token_hdr);
key_p->pubHdr.token_length = key_len;
key_len += 4;
itoLe2(&key_len, keyb_p->ulen);
key_len += 2;
itoLe2(&key_len, keyb_p->blen);
parmBlock_l -= pad_len;
itoLe2(&parmBlock_l, cprb_p->req_parml);
*z90cMsg_l_p = tmp_size - CALLER_HEADER;
return 0;
}
static int
ICACRT_msg_to_type6CRT_msg(struct ica_rsa_modexpo_crt *icaMsg_p, int cdx,
int *z90cMsg_l_p, struct type6_msg *z90cMsg_p)
{
int mod_len, vud_len, tmp_size, total_CPRB_len, parmBlock_l, short_len;
int long_len, pad_len, keyPartsLen, tmp_l;
unsigned char *tgt_p, *temp;
struct type6_hdr *tp6Hdr_p;
struct CPRB *cprb_p;
struct cca_token_hdr *keyHdr_p;
struct cca_pvt_ext_CRT_sec *pvtSec_p;
struct cca_public_sec *pubSec_p;
mod_len = icaMsg_p->inputdatalength;
short_len = mod_len / 2;
long_len = 8 + short_len;
keyPartsLen = 3 * long_len + 2 * short_len;
pad_len = (8 - (keyPartsLen % 8)) % 8;
keyPartsLen += pad_len + mod_len;
tmp_size = FIXED_TYPE6_CR_LEN + keyPartsLen + mod_len;
total_CPRB_len = tmp_size - sizeof(struct type6_hdr);
parmBlock_l = total_CPRB_len - sizeof(struct CPRB);
vud_len = 2 + mod_len;
tmp_size = 4*((tmp_size + 3)/4) + CALLER_HEADER;
memset(z90cMsg_p, 0, tmp_size);
tgt_p = (unsigned char *)z90cMsg_p + CALLER_HEADER;
memcpy(tgt_p, &static_type6_hdr, sizeof(struct type6_hdr));
tp6Hdr_p = (struct type6_hdr *)tgt_p;
tp6Hdr_p->ToCardLen1 = 4*((total_CPRB_len+3)/4);
tp6Hdr_p->FromCardLen1 = RESPONSE_CPRB_SIZE;
tgt_p += sizeof(struct type6_hdr);
cprb_p = (struct CPRB *) tgt_p;
memcpy(tgt_p, &static_cprb, sizeof(struct CPRB));
cprb_p->usage_domain[0]= *((unsigned char *)(&(cdx))+3);
itoLe2(&parmBlock_l, cprb_p->req_parml);
memcpy(cprb_p->rpl_parml, cprb_p->req_parml,
sizeof(cprb_p->req_parml));
tgt_p += sizeof(struct CPRB);
memcpy(tgt_p, &static_pkd_function_and_rules,
sizeof(struct function_and_rules_block));
tgt_p += sizeof(struct function_and_rules_block);
itoLe2(&vud_len, tgt_p);
tgt_p += 2;
if (copy_from_user(tgt_p, icaMsg_p->inputdata, mod_len))
return SEN_RELEASED;
if (is_empty(tgt_p, mod_len))
return SEN_USER_ERROR;
tgt_p += mod_len;
tmp_l = sizeof(struct T6_keyBlock_hdr) + sizeof(struct cca_token_hdr) +
sizeof(struct cca_pvt_ext_CRT_sec) + 0x0F + keyPartsLen;
itoLe2(&tmp_l, tgt_p);
temp = tgt_p + 2;
tmp_l -= 2;
itoLe2(&tmp_l, temp);
tgt_p += sizeof(struct T6_keyBlock_hdr);
keyHdr_p = (struct cca_token_hdr *)tgt_p;
keyHdr_p->token_identifier = CCA_TKN_HDR_ID_EXT;
tmp_l -= 4;
keyHdr_p->token_length = tmp_l;
tgt_p += sizeof(struct cca_token_hdr);
pvtSec_p = (struct cca_pvt_ext_CRT_sec *)tgt_p;
pvtSec_p->section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT;
pvtSec_p->section_length =
sizeof(struct cca_pvt_ext_CRT_sec) + keyPartsLen;
pvtSec_p->key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL;
pvtSec_p->key_use_flags[0] = CCA_PVT_USAGE_ALL;
pvtSec_p->p_len = long_len;
pvtSec_p->q_len = short_len;
pvtSec_p->dp_len = long_len;
pvtSec_p->dq_len = short_len;
pvtSec_p->u_len = long_len;
pvtSec_p->mod_len = mod_len;
pvtSec_p->pad_len = pad_len;
tgt_p += sizeof(struct cca_pvt_ext_CRT_sec);
if (copy_from_user(tgt_p, icaMsg_p->np_prime, long_len))
return SEN_RELEASED;
if (is_empty(tgt_p, long_len))
return SEN_USER_ERROR;
tgt_p += long_len;
if (copy_from_user(tgt_p, icaMsg_p->nq_prime, short_len))
return SEN_RELEASED;
if (is_empty(tgt_p, short_len))
return SEN_USER_ERROR;
tgt_p += short_len;
if (copy_from_user(tgt_p, icaMsg_p->bp_key, long_len))
return SEN_RELEASED;
if (is_empty(tgt_p, long_len))
return SEN_USER_ERROR;
tgt_p += long_len;
if (copy_from_user(tgt_p, icaMsg_p->bq_key, short_len))
return SEN_RELEASED;
if (is_empty(tgt_p, short_len))
return SEN_USER_ERROR;
tgt_p += short_len;
if (copy_from_user(tgt_p, icaMsg_p->u_mult_inv, long_len))
return SEN_RELEASED;
if (is_empty(tgt_p, long_len))
return SEN_USER_ERROR;
tgt_p += long_len;
tgt_p += pad_len;
memset(tgt_p, 0xFF, mod_len);
tgt_p += mod_len;
memcpy(tgt_p, &static_cca_pub_sec, sizeof(struct cca_public_sec));
pubSec_p = (struct cca_public_sec *) tgt_p;
pubSec_p->modulus_bit_len = 8 * mod_len;
*z90cMsg_l_p = tmp_size - CALLER_HEADER;
return 0;
}
static int
ICAMEX_msg_to_type6MEX_msgX(struct ica_rsa_modexpo *icaMsg_p, int cdx,
int *z90cMsg_l_p, struct type6_msg *z90cMsg_p,
int dev_type)
{
int mod_len, exp_len, vud_len, tmp_size, total_CPRB_len, parmBlock_l;
int key_len, i;
unsigned char *temp_exp, *tgt_p, *temp, *exp_p;
struct type6_hdr *tp6Hdr_p;
struct CPRBX *cprbx_p;
struct cca_public_key *key_p;
struct T6_keyBlock_hdrX *keyb_p;
temp_exp = kmalloc(256, GFP_KERNEL);
if (!temp_exp)
return EGETBUFF;
mod_len = icaMsg_p->inputdatalength;
if (copy_from_user(temp_exp, icaMsg_p->b_key, mod_len)) {
kfree(temp_exp);
return SEN_RELEASED;
}
if (is_empty(temp_exp, mod_len)) {
kfree(temp_exp);
return SEN_USER_ERROR;
}
exp_p = temp_exp;
for (i = 0; i < mod_len; i++)
if (exp_p[i])
break;
if (i >= mod_len) {
kfree(temp_exp);
return SEN_USER_ERROR;
}
exp_len = mod_len - i;
exp_p += i;
PDEBUG("exp_len after computation: %08x\n", exp_len);
tmp_size = FIXED_TYPE6_ME_EN_LENX + 2 * mod_len + exp_len;
total_CPRB_len = tmp_size - sizeof(struct type6_hdr);
parmBlock_l = total_CPRB_len - sizeof(struct CPRBX);
tmp_size = tmp_size + CALLER_HEADER;
vud_len = 2 + mod_len;
memset(z90cMsg_p, 0, tmp_size);
tgt_p = (unsigned char *)z90cMsg_p + CALLER_HEADER;
memcpy(tgt_p, &static_type6_hdrX, sizeof(struct type6_hdr));
tp6Hdr_p = (struct type6_hdr *)tgt_p;
tp6Hdr_p->ToCardLen1 = total_CPRB_len;
tp6Hdr_p->FromCardLen1 = RESPONSE_CPRBX_SIZE;
memcpy(tp6Hdr_p->function_code, static_PKE_function_code,
sizeof(static_PKE_function_code));
tgt_p += sizeof(struct type6_hdr);
memcpy(tgt_p, &static_cprbx, sizeof(struct CPRBX));
cprbx_p = (struct CPRBX *) tgt_p;
cprbx_p->domain = (unsigned short)cdx;
cprbx_p->rpl_msgbl = RESPONSE_CPRBX_SIZE;
tgt_p += sizeof(struct CPRBX);
if (dev_type == PCIXCC_MCL2)
memcpy(tgt_p, &static_pke_function_and_rulesX_MCL2,
sizeof(struct function_and_rules_block));
else
memcpy(tgt_p, &static_pke_function_and_rulesX,
sizeof(struct function_and_rules_block));
tgt_p += sizeof(struct function_and_rules_block);
tgt_p += 2;
if (copy_from_user(tgt_p, icaMsg_p->inputdata, mod_len)) {
kfree(temp_exp);
return SEN_RELEASED;
}
if (is_empty(tgt_p, mod_len)) {
kfree(temp_exp);
return SEN_USER_ERROR;
}
tgt_p -= 2;
*((short *)tgt_p) = (short) vud_len;
tgt_p += vud_len;
keyb_p = (struct T6_keyBlock_hdrX *)tgt_p;
tgt_p += sizeof(struct T6_keyBlock_hdrX);
memcpy(tgt_p, &static_public_key, sizeof(static_public_key));
key_p = (struct cca_public_key *)tgt_p;
temp = key_p->pubSec.exponent;
memcpy(temp, exp_p, exp_len);
kfree(temp_exp);
temp += exp_len;
if (copy_from_user(temp, icaMsg_p->n_modulus, mod_len))
return SEN_RELEASED;
if (is_empty(temp, mod_len))
return SEN_USER_ERROR;
key_p->pubSec.modulus_bit_len = 8 * mod_len;
key_p->pubSec.modulus_byte_len = mod_len;
key_p->pubSec.exponent_len = exp_len;
key_p->pubSec.section_length = CALLER_HEADER + mod_len + exp_len;
key_len = key_p->pubSec.section_length + sizeof(struct cca_token_hdr);
key_p->pubHdr.token_length = key_len;
key_len += 4;
keyb_p->ulen = (unsigned short)key_len;
key_len += 2;
keyb_p->blen = (unsigned short)key_len;
cprbx_p->req_parml = parmBlock_l;
*z90cMsg_l_p = tmp_size - CALLER_HEADER;
return 0;
}
static int
ICACRT_msg_to_type6CRT_msgX(struct ica_rsa_modexpo_crt *icaMsg_p, int cdx,
int *z90cMsg_l_p, struct type6_msg *z90cMsg_p,
int dev_type)
{
int mod_len, vud_len, tmp_size, total_CPRB_len, parmBlock_l, short_len;
int long_len, pad_len, keyPartsLen, tmp_l;
unsigned char *tgt_p, *temp;
struct type6_hdr *tp6Hdr_p;
struct CPRBX *cprbx_p;
struct cca_token_hdr *keyHdr_p;
struct cca_pvt_ext_CRT_sec *pvtSec_p;
struct cca_public_sec *pubSec_p;
mod_len = icaMsg_p->inputdatalength;
short_len = mod_len / 2;
long_len = 8 + short_len;
keyPartsLen = 3 * long_len + 2 * short_len;
pad_len = (8 - (keyPartsLen % 8)) % 8;
keyPartsLen += pad_len + mod_len;
tmp_size = FIXED_TYPE6_CR_LENX + keyPartsLen + mod_len;
total_CPRB_len = tmp_size - sizeof(struct type6_hdr);
parmBlock_l = total_CPRB_len - sizeof(struct CPRBX);
vud_len = 2 + mod_len;
tmp_size = tmp_size + CALLER_HEADER;
memset(z90cMsg_p, 0, tmp_size);
tgt_p = (unsigned char *)z90cMsg_p + CALLER_HEADER;
memcpy(tgt_p, &static_type6_hdrX, sizeof(struct type6_hdr));
tp6Hdr_p = (struct type6_hdr *)tgt_p;
tp6Hdr_p->ToCardLen1 = total_CPRB_len;
tp6Hdr_p->FromCardLen1 = RESPONSE_CPRBX_SIZE;
tgt_p += sizeof(struct type6_hdr);
cprbx_p = (struct CPRBX *) tgt_p;
memcpy(tgt_p, &static_cprbx, sizeof(struct CPRBX));
cprbx_p->domain = (unsigned short)cdx;
cprbx_p->req_parml = parmBlock_l;
cprbx_p->rpl_msgbl = parmBlock_l;
tgt_p += sizeof(struct CPRBX);
if (dev_type == PCIXCC_MCL2)
memcpy(tgt_p, &static_pkd_function_and_rulesX_MCL2,
sizeof(struct function_and_rules_block));
else
memcpy(tgt_p, &static_pkd_function_and_rulesX,
sizeof(struct function_and_rules_block));
tgt_p += sizeof(struct function_and_rules_block);
*((short *)tgt_p) = (short) vud_len;
tgt_p += 2;
if (copy_from_user(tgt_p, icaMsg_p->inputdata, mod_len))
return SEN_RELEASED;
if (is_empty(tgt_p, mod_len))
return SEN_USER_ERROR;
tgt_p += mod_len;
tmp_l = sizeof(struct T6_keyBlock_hdr) + sizeof(struct cca_token_hdr) +
sizeof(struct cca_pvt_ext_CRT_sec) + 0x0F + keyPartsLen;
*((short *)tgt_p) = (short) tmp_l;
temp = tgt_p + 2;
tmp_l -= 2;
*((short *)temp) = (short) tmp_l;
tgt_p += sizeof(struct T6_keyBlock_hdr);
keyHdr_p = (struct cca_token_hdr *)tgt_p;
keyHdr_p->token_identifier = CCA_TKN_HDR_ID_EXT;
tmp_l -= 4;
keyHdr_p->token_length = tmp_l;
tgt_p += sizeof(struct cca_token_hdr);
pvtSec_p = (struct cca_pvt_ext_CRT_sec *)tgt_p;
pvtSec_p->section_identifier = CCA_PVT_EXT_CRT_SEC_ID_PVT;
pvtSec_p->section_length =
sizeof(struct cca_pvt_ext_CRT_sec) + keyPartsLen;
pvtSec_p->key_format = CCA_PVT_EXT_CRT_SEC_FMT_CL;
pvtSec_p->key_use_flags[0] = CCA_PVT_USAGE_ALL;
pvtSec_p->p_len = long_len;
pvtSec_p->q_len = short_len;
pvtSec_p->dp_len = long_len;
pvtSec_p->dq_len = short_len;
pvtSec_p->u_len = long_len;
pvtSec_p->mod_len = mod_len;
pvtSec_p->pad_len = pad_len;
tgt_p += sizeof(struct cca_pvt_ext_CRT_sec);
if (copy_from_user(tgt_p, icaMsg_p->np_prime, long_len))
return SEN_RELEASED;
if (is_empty(tgt_p, long_len))
return SEN_USER_ERROR;
tgt_p += long_len;
if (copy_from_user(tgt_p, icaMsg_p->nq_prime, short_len))
return SEN_RELEASED;
if (is_empty(tgt_p, short_len))
return SEN_USER_ERROR;
tgt_p += short_len;
if (copy_from_user(tgt_p, icaMsg_p->bp_key, long_len))
return SEN_RELEASED;
if (is_empty(tgt_p, long_len))
return SEN_USER_ERROR;
tgt_p += long_len;
if (copy_from_user(tgt_p, icaMsg_p->bq_key, short_len))
return SEN_RELEASED;
if (is_empty(tgt_p, short_len))
return SEN_USER_ERROR;
tgt_p += short_len;
if (copy_from_user(tgt_p, icaMsg_p->u_mult_inv, long_len))
return SEN_RELEASED;
if (is_empty(tgt_p, long_len))
return SEN_USER_ERROR;
tgt_p += long_len;
tgt_p += pad_len;
memset(tgt_p, 0xFF, mod_len);
tgt_p += mod_len;
memcpy(tgt_p, &static_cca_pub_sec, sizeof(struct cca_public_sec));
pubSec_p = (struct cca_public_sec *) tgt_p;
pubSec_p->modulus_bit_len = 8 * mod_len;
*z90cMsg_l_p = tmp_size - CALLER_HEADER;
return 0;
}
static int
ICAMEX_msg_to_type50MEX_msg(struct ica_rsa_modexpo *icaMex_p, int *z90cMsg_l_p,
union type50_msg *z90cMsg_p)
{
int mod_len, msg_size, mod_tgt_len, exp_tgt_len, inp_tgt_len;
unsigned char *mod_tgt, *exp_tgt, *inp_tgt;
union type50_msg *tmp_type50_msg;
mod_len = icaMex_p->inputdatalength;
msg_size = ((mod_len <= 128) ? TYPE50_MEB1_LEN : TYPE50_MEB2_LEN) +
CALLER_HEADER;
memset(z90cMsg_p, 0, msg_size);
tmp_type50_msg = (union type50_msg *)
((unsigned char *) z90cMsg_p + CALLER_HEADER);
tmp_type50_msg->meb1.header.msg_type_code = TYPE50_TYPE_CODE;
if (mod_len <= 128) {
tmp_type50_msg->meb1.header.msg_len = TYPE50_MEB1_LEN;
tmp_type50_msg->meb1.keyblock_type = TYPE50_MEB1_FMT;
mod_tgt = tmp_type50_msg->meb1.modulus;
mod_tgt_len = sizeof(tmp_type50_msg->meb1.modulus);
exp_tgt = tmp_type50_msg->meb1.exponent;
exp_tgt_len = sizeof(tmp_type50_msg->meb1.exponent);
inp_tgt = tmp_type50_msg->meb1.message;
inp_tgt_len = sizeof(tmp_type50_msg->meb1.message);
} else {
tmp_type50_msg->meb2.header.msg_len = TYPE50_MEB2_LEN;
tmp_type50_msg->meb2.keyblock_type = TYPE50_MEB2_FMT;
mod_tgt = tmp_type50_msg->meb2.modulus;
mod_tgt_len = sizeof(tmp_type50_msg->meb2.modulus);
exp_tgt = tmp_type50_msg->meb2.exponent;
exp_tgt_len = sizeof(tmp_type50_msg->meb2.exponent);
inp_tgt = tmp_type50_msg->meb2.message;
inp_tgt_len = sizeof(tmp_type50_msg->meb2.message);
}
mod_tgt += (mod_tgt_len - mod_len);
if (copy_from_user(mod_tgt, icaMex_p->n_modulus, mod_len))
return SEN_RELEASED;
if (is_empty(mod_tgt, mod_len))
return SEN_USER_ERROR;
exp_tgt += (exp_tgt_len - mod_len);
if (copy_from_user(exp_tgt, icaMex_p->b_key, mod_len))
return SEN_RELEASED;
if (is_empty(exp_tgt, mod_len))
return SEN_USER_ERROR;
inp_tgt += (inp_tgt_len - mod_len);
if (copy_from_user(inp_tgt, icaMex_p->inputdata, mod_len))
return SEN_RELEASED;
if (is_empty(inp_tgt, mod_len))
return SEN_USER_ERROR;
*z90cMsg_l_p = msg_size - CALLER_HEADER;
return 0;
}
static int
ICACRT_msg_to_type50CRT_msg(struct ica_rsa_modexpo_crt *icaMsg_p,
int *z90cMsg_l_p, union type50_msg *z90cMsg_p)
{
int mod_len, short_len, long_len, tmp_size, p_tgt_len, q_tgt_len,
dp_tgt_len, dq_tgt_len, u_tgt_len, inp_tgt_len, long_offset;
unsigned char *p_tgt, *q_tgt, *dp_tgt, *dq_tgt, *u_tgt, *inp_tgt,
temp[8];
union type50_msg *tmp_type50_msg;
mod_len = icaMsg_p->inputdatalength;
short_len = mod_len / 2;
long_len = mod_len / 2 + 8;
long_offset = 0;
if (long_len > 128) {
memset(temp, 0x00, sizeof(temp));
if (copy_from_user(temp, icaMsg_p->np_prime, long_len-128))
return SEN_RELEASED;
if (!is_empty(temp, 8))
return SEN_NOT_AVAIL;
if (copy_from_user(temp, icaMsg_p->bp_key, long_len-128))
return SEN_RELEASED;
if (!is_empty(temp, 8))
return SEN_NOT_AVAIL;
if (copy_from_user(temp, icaMsg_p->u_mult_inv, long_len-128))
return SEN_RELEASED;
if (!is_empty(temp, 8))
return SEN_NOT_AVAIL;
long_offset = long_len - 128;
long_len = 128;
}
tmp_size = ((long_len <= 64) ? TYPE50_CRB1_LEN : TYPE50_CRB2_LEN) +
CALLER_HEADER;
memset(z90cMsg_p, 0, tmp_size);
tmp_type50_msg = (union type50_msg *)
((unsigned char *) z90cMsg_p + CALLER_HEADER);
tmp_type50_msg->crb1.header.msg_type_code = TYPE50_TYPE_CODE;
if (long_len <= 64) {
tmp_type50_msg->crb1.header.msg_len = TYPE50_CRB1_LEN;
tmp_type50_msg->crb1.keyblock_type = TYPE50_CRB1_FMT;
p_tgt = tmp_type50_msg->crb1.p;
p_tgt_len = sizeof(tmp_type50_msg->crb1.p);
q_tgt = tmp_type50_msg->crb1.q;
q_tgt_len = sizeof(tmp_type50_msg->crb1.q);
dp_tgt = tmp_type50_msg->crb1.dp;
dp_tgt_len = sizeof(tmp_type50_msg->crb1.dp);
dq_tgt = tmp_type50_msg->crb1.dq;
dq_tgt_len = sizeof(tmp_type50_msg->crb1.dq);
u_tgt = tmp_type50_msg->crb1.u;
u_tgt_len = sizeof(tmp_type50_msg->crb1.u);
inp_tgt = tmp_type50_msg->crb1.message;
inp_tgt_len = sizeof(tmp_type50_msg->crb1.message);
} else {
tmp_type50_msg->crb2.header.msg_len = TYPE50_CRB2_LEN;
tmp_type50_msg->crb2.keyblock_type = TYPE50_CRB2_FMT;
p_tgt = tmp_type50_msg->crb2.p;
p_tgt_len = sizeof(tmp_type50_msg->crb2.p);
q_tgt = tmp_type50_msg->crb2.q;
q_tgt_len = sizeof(tmp_type50_msg->crb2.q);
dp_tgt = tmp_type50_msg->crb2.dp;
dp_tgt_len = sizeof(tmp_type50_msg->crb2.dp);
dq_tgt = tmp_type50_msg->crb2.dq;
dq_tgt_len = sizeof(tmp_type50_msg->crb2.dq);
u_tgt = tmp_type50_msg->crb2.u;
u_tgt_len = sizeof(tmp_type50_msg->crb2.u);
inp_tgt = tmp_type50_msg->crb2.message;
inp_tgt_len = sizeof(tmp_type50_msg->crb2.message);
}
p_tgt += (p_tgt_len - long_len);
if (copy_from_user(p_tgt, icaMsg_p->np_prime + long_offset, long_len))
return SEN_RELEASED;
if (is_empty(p_tgt, long_len))
return SEN_USER_ERROR;
q_tgt += (q_tgt_len - short_len);
if (copy_from_user(q_tgt, icaMsg_p->nq_prime, short_len))
return SEN_RELEASED;
if (is_empty(q_tgt, short_len))
return SEN_USER_ERROR;
dp_tgt += (dp_tgt_len - long_len);
if (copy_from_user(dp_tgt, icaMsg_p->bp_key + long_offset, long_len))
return SEN_RELEASED;
if (is_empty(dp_tgt, long_len))
return SEN_USER_ERROR;
dq_tgt += (dq_tgt_len - short_len);
if (copy_from_user(dq_tgt, icaMsg_p->bq_key, short_len))
return SEN_RELEASED;
if (is_empty(dq_tgt, short_len))
return SEN_USER_ERROR;
u_tgt += (u_tgt_len - long_len);
if (copy_from_user(u_tgt, icaMsg_p->u_mult_inv + long_offset, long_len))
return SEN_RELEASED;
if (is_empty(u_tgt, long_len))
return SEN_USER_ERROR;
inp_tgt += (inp_tgt_len - mod_len);
if (copy_from_user(inp_tgt, icaMsg_p->inputdata, mod_len))
return SEN_RELEASED;
if (is_empty(inp_tgt, mod_len))
return SEN_USER_ERROR;
*z90cMsg_l_p = tmp_size - CALLER_HEADER;
return 0;
}
int
convert_request(unsigned char *buffer, int func, unsigned short function,
int cdx, int dev_type, int *msg_l_p, unsigned char *msg_p)
{
if (dev_type == PCICA) {
if (func == ICARSACRT)
return ICACRT_msg_to_type4CRT_msg(
(struct ica_rsa_modexpo_crt *) buffer,
msg_l_p, (union type4_msg *) msg_p);
else
return ICAMEX_msg_to_type4MEX_msg(
(struct ica_rsa_modexpo *) buffer,
msg_l_p, (union type4_msg *) msg_p);
}
if (dev_type == PCICC) {
if (func == ICARSACRT)
return ICACRT_msg_to_type6CRT_msg(
(struct ica_rsa_modexpo_crt *) buffer,
cdx, msg_l_p, (struct type6_msg *)msg_p);
if (function == PCI_FUNC_KEY_ENCRYPT)
return ICAMEX_msg_to_type6MEX_en_msg(
(struct ica_rsa_modexpo *) buffer,
cdx, msg_l_p, (struct type6_msg *) msg_p);
else
return ICAMEX_msg_to_type6MEX_de_msg(
(struct ica_rsa_modexpo *) buffer,
cdx, msg_l_p, (struct type6_msg *) msg_p);
}
if ((dev_type == PCIXCC_MCL2) ||
(dev_type == PCIXCC_MCL3) ||
(dev_type == CEX2C)) {
if (func == ICARSACRT)
return ICACRT_msg_to_type6CRT_msgX(
(struct ica_rsa_modexpo_crt *) buffer,
cdx, msg_l_p, (struct type6_msg *) msg_p,
dev_type);
else
return ICAMEX_msg_to_type6MEX_msgX(
(struct ica_rsa_modexpo *) buffer,
cdx, msg_l_p, (struct type6_msg *) msg_p,
dev_type);
}
if (dev_type == CEX2A) {
if (func == ICARSACRT)
return ICACRT_msg_to_type50CRT_msg(
(struct ica_rsa_modexpo_crt *) buffer,
msg_l_p, (union type50_msg *) msg_p);
else
return ICAMEX_msg_to_type50MEX_msg(
(struct ica_rsa_modexpo *) buffer,
msg_l_p, (union type50_msg *) msg_p);
}
return 0;
}
int ext_bitlens_msg_count = 0;
static inline void
unset_ext_bitlens(void)
{
if (!ext_bitlens_msg_count) {
PRINTK("Unable to use coprocessors for extended bitlengths. "
"Using PCICAs/CEX2As (if present) for extended "
"bitlengths. This is not an error.\n");
ext_bitlens_msg_count++;
}
ext_bitlens = 0;
}
int
convert_response(unsigned char *response, unsigned char *buffer,
int *respbufflen_p, unsigned char *resp_buff)
{
struct ica_rsa_modexpo *icaMsg_p = (struct ica_rsa_modexpo *) buffer;
struct error_hdr *errh_p = (struct error_hdr *) response;
struct type80_hdr *t80h_p = (struct type80_hdr *) response;
struct type84_hdr *t84h_p = (struct type84_hdr *) response;
struct type86_fmt2_msg *t86m_p = (struct type86_fmt2_msg *) response;
int reply_code, service_rc, service_rs, src_l;
unsigned char *src_p, *tgt_p;
struct CPRB *cprb_p;
struct CPRBX *cprbx_p;
src_p = 0;
reply_code = 0;
service_rc = 0;
service_rs = 0;
src_l = 0;
switch (errh_p->type) {
case TYPE82_RSP_CODE:
case TYPE88_RSP_CODE:
reply_code = errh_p->reply_code;
src_p = (unsigned char *)errh_p;
PRINTK("Hardware error: Type %02X Message Header: "
"%02x%02x%02x%02x%02x%02x%02x%02x\n",
errh_p->type,
src_p[0], src_p[1], src_p[2], src_p[3],
src_p[4], src_p[5], src_p[6], src_p[7]);
break;
case TYPE80_RSP_CODE:
src_l = icaMsg_p->outputdatalength;
src_p = response + (int)t80h_p->len - src_l;
break;
case TYPE84_RSP_CODE:
src_l = icaMsg_p->outputdatalength;
src_p = response + (int)t84h_p->len - src_l;
break;
case TYPE86_RSP_CODE:
reply_code = t86m_p->header.reply_code;
if (reply_code != 0)
break;
cprb_p = (struct CPRB *)
(response + sizeof(struct type86_fmt2_msg));
cprbx_p = (struct CPRBX *) cprb_p;
if (cprb_p->cprb_ver_id != 0x02) {
le2toI(cprb_p->ccp_rtcode, &service_rc);
if (service_rc != 0) {
le2toI(cprb_p->ccp_rscode, &service_rs);
if ((service_rc == 8) && (service_rs == 66))
PDEBUG("Bad block format on PCICC\n");
else if ((service_rc == 8) && (service_rs == 65))
PDEBUG("Probably an even modulus on "
"PCICC\n");
else if ((service_rc == 8) && (service_rs == 770)) {
PDEBUG("Invalid key length on PCICC\n");
unset_ext_bitlens();
return REC_USE_PCICA;
}
else if ((service_rc == 8) && (service_rs == 783)) {
PDEBUG("Extended bitlengths not enabled"
"on PCICC\n");
unset_ext_bitlens();
return REC_USE_PCICA;
}
else
PRINTK("service rc/rs (PCICC): %d/%d\n",
service_rc, service_rs);
return REC_OPERAND_INV;
}
src_p = (unsigned char *)cprb_p + sizeof(struct CPRB);
src_p += 4;
le2toI(src_p, &src_l);
src_l -= 2;
src_p += 2;
} else {
service_rc = (int)cprbx_p->ccp_rtcode;
if (service_rc != 0) {
service_rs = (int) cprbx_p->ccp_rscode;
if ((service_rc == 8) && (service_rs == 66))
PDEBUG("Bad block format on PCIXCC\n");
else if ((service_rc == 8) && (service_rs == 65))
PDEBUG("Probably an even modulus on "
"PCIXCC\n");
else if ((service_rc == 8) && (service_rs == 770)) {
PDEBUG("Invalid key length on PCIXCC\n");
unset_ext_bitlens();
return REC_USE_PCICA;
}
else if ((service_rc == 8) && (service_rs == 783)) {
PDEBUG("Extended bitlengths not enabled"
"on PCIXCC\n");
unset_ext_bitlens();
return REC_USE_PCICA;
}
else
PRINTK("service rc/rs (PCIXCC): %d/%d\n",
service_rc, service_rs);
return REC_OPERAND_INV;
}
src_p = (unsigned char *)
cprbx_p + sizeof(struct CPRBX);
src_p += 4;
src_l = (int)(*((short *) src_p));
src_l -= 2;
src_p += 2;
}
break;
default:
src_p = (unsigned char *)errh_p;
PRINTK("Unrecognized Message Header: "
"%02x%02x%02x%02x%02x%02x%02x%02x\n",
src_p[0], src_p[1], src_p[2], src_p[3],
src_p[4], src_p[5], src_p[6], src_p[7]);
return REC_BAD_MESSAGE;
}
if (reply_code)
switch (reply_code) {
case REP82_ERROR_MACHINE_FAILURE:
if (errh_p->type == TYPE82_RSP_CODE)
PRINTKW("Machine check failure\n");
else
PRINTKW("Module failure\n");
return REC_HARDWAR_ERR;
case REP82_ERROR_OPERAND_INVALID:
return REC_OPERAND_INV;
case REP88_ERROR_MESSAGE_MALFORMD:
PRINTKW("Message malformed\n");
return REC_OPERAND_INV;
case REP82_ERROR_OPERAND_SIZE:
return REC_OPERAND_SIZE;
case REP82_ERROR_EVEN_MOD_IN_OPND:
return REC_EVEN_MOD;
case REP82_ERROR_MESSAGE_TYPE:
return WRONG_DEVICE_TYPE;
case REP82_ERROR_TRANSPORT_FAIL:
PRINTKW("Transport failed (APFS = %02X%02X%02X%02X)\n",
t86m_p->apfs[0], t86m_p->apfs[1],
t86m_p->apfs[2], t86m_p->apfs[3]);
return REC_HARDWAR_ERR;
default:
PRINTKW("reply code = %d\n", reply_code);
return REC_HARDWAR_ERR;
}
if (service_rc != 0)
return REC_OPERAND_INV;
if ((src_l > icaMsg_p->outputdatalength) ||
(src_l > RESPBUFFSIZE) ||
(src_l <= 0))
return REC_OPERAND_SIZE;
PDEBUG("Length returned = %d\n", src_l);
tgt_p = resp_buff + icaMsg_p->outputdatalength - src_l;
memcpy(tgt_p, src_p, src_l);
if ((errh_p->type == TYPE86_RSP_CODE) && (resp_buff < tgt_p)) {
memset(resp_buff, 0, icaMsg_p->outputdatalength - src_l);
if (pad_msg(resp_buff, icaMsg_p->outputdatalength, src_l))
return REC_INVALID_PAD;
}
*respbufflen_p = icaMsg_p->outputdatalength;
if (*respbufflen_p == 0)
PRINTK("Zero *respbufflen_p\n");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink