磁针石: 可信计算（new）

7月9日
TCM密钥分析
typedef struct tdTCM_KEY{
TCM_STRUCTURE_TAG tag;     2bytes
UINT16 fill;    2bytes
TCM_KEY_USAGE keyUsage;            2bytes
TCM_KEY_FLAGS       keyFlags; 4bytes
TCM_AUTH_DATA_USAGE authDataUsage;      1byte
TCM_KEY_PARAM algorithmParms;   max 22bytes
UINT32 PCRInfoSize;   4bytes
BYTE* PCRInfo;   max 80bytes
TCM_STORE_PUBKEY pubKey;  max 69bytes
UINT32 encDataSize;    4bytes
[size_is(encDataSize)] encData; max 230bytes
}TCM_KEY
TCM_KEY实例
00 15     //tag
00 00     //fill
00 11      //keyUsage
00 00 00 00   //keyFlags
01                  //authDataUsage
00 00 00 0B 00 06 00 01 00 00 00 04 00 00 01 00     //algorithmParms
// 最后4个字节是TCM_ECC_ASYMKEY_PARAMETERS, 密钥长度0x00000100=256字节
00 00 00 00 00 00 00 41
04 E0 C4 92 0C 82 91 0B F8 A4 73 00 23 CE 6C F0 22 9E D7 1B 9A 1F D7 8D 09 69 DB 2F A7 91 AF 5A F6 2A AC 7B 7D C5 37 E9 A2 16 08 F5 EE 83 76 49 A7 08 8B 02 31 8A 66 2C 58 B4 47 10 6A 86 B3 39 B0   // TCM_STORE_PUBKEY结构，04表示公钥点Q采用未压缩格式存储，1(04)+32+32 = 65bytes
00 00 00 90          //encDataSize, 被加密的私钥（也可能是都对称密钥）长度0x90=144bytes
42 99 89 C0 2D 47 CE 95 D9 1B 99 87 B0 79 09 34 64 5B 8E 51 69 C5 9C D6 49 3A 1B DA 60 B5 04 28 83 F2 7A A8 51 96 99 3B D8 13 31 85 66 01 4B 09 B9 20 CD 83 0E 08 9E 32 13 93 01 C3 46 BB 37 8F 2B CB 50 50 EB 84 18 7E D8 B0 C1 37 67 24 B0 41 2C 70 AB 07 6A A7 6D 03 B8 DF BA 00 45 AB 31 B5 90 CF F3 0D 44 5B 48 5F E3 82 63 45 39 36 0A C3 7B 88 A9 74 27 E3 85 2A 94 17 29 E7 6A D1 81 9A 36 BE 82 BC D9 9B 3D 40 0A C1 53 7A 6F C7 B6 5B
// 本实例是被父密钥加密的私钥TCM_STORE_ASYMKEY
10:45 |添加评论 |阅读评论 (4) |固定链接 |写入日志 |可信计算
5月21日
TPM互操作分析（二）
前面讨论外部密钥导入TPM内部使用的互操作问题，这里将讨论TPM内部密钥导出使用的互操作问题。我们首先分析TPM迁移密钥Blob生成的过程，然后针对该过程将TPM内部密钥导出，获取TPM密钥的明文，以便被其他设备、软件所使用。
TPM迁移密钥的过程：
==>TPM_AuthorizeMigrationKey         TPM Owner授权用来迁移的保护密钥，生成迁移时用到的TPM_MIGRATIONKEYAUTH
==>TPM_CreateMigrationBlob            在TPM内部创建迁移包
==>TPM_ConvertMigrationBlob          在迁移目标平台，将MigrationBlob转换为受目标平台TPM保护的WrappedBlob。
其中导出TPM内部密钥（包含私钥）主要是TPM_AuthorizeMigrationKey和TPM_CreateMigrationBlob这两步，其结果是生成了迁移密钥包。TPM Migration命令支持的迁移有两种方式：TPM_MS_REWRAP方式和TPM_MS_MIGRATE方式，前一种方式在TPM内部直接使用公钥（迁移目标平台父密钥）Wrap被迁移密钥的受保护部分TPM_STORE_ASYMKEY；后一种方式安全性更高，使用迁移Blob保护迁移密钥。TPM能够被迁移的密钥类型包括加密密钥、签名密钥、Legacy密钥，存储密钥和Identity Key不允许被迁移。在执行迁移操作之前，TPM首先要验证该密钥类型是否允许迁移。
TPM_AuthorizeMigrationKey要求输入用于迁移保护密钥的公钥，结构为TPM_PUBKEY，用于迁移保护的RSA公钥算法必须为TPM_ES_RSAESOAEP_SHA1_MGF1的加密方案，另外还需要设置迁移方式(TPM_MIGRATE_SCHEME)，是直接Rewrap迁移，还是使用Migrate命令迁移，或迁移至MA...。TPM_AuthorizeMigrationKey生成了了用于迁移认证的TPM_MIGRATIONKEYAUTH授权数据，该授权数据的生成方式请参考TPM命令规范。
TPM_CreateMigrationBlob的主要功能是生成TPM MigrationBlob，该Blob受迁移保护密钥的加密保护。
1. TPM首先验证迁移授权TPM_MIGRATIONKEYAUTH，其中digest=SHA-1(migrationKey || migrationScheme || TPM_PERMANENT_DATA -> tpmProof), TPM使用内部的tpmproof计算出digest与TPM_MIGRATIONKEYAUTH中的比较。
typedef struct tdTPM_MIGRATIONKEYAUTH{
TPM_PUBKEY migrationKey;
TPM_MIGRATE_SCHEME migrationScheme;
TPM_DIGEST digest;
} TPM_MIGRATIONKEYAUTH;
2. TPM使用父密钥解密需要迁移的密钥WrappedBlob encData（结构为TPM_STORE_ASYMKEY密文），紧接着TPM使用TPM_STORE_ASYMKEY中的migrationAuth按照OIAP会话的HMAC计算方法验证授权值entityAuth。
3. 如果TPM采用TPM_MS_REWRAP方式迁移则非常简单（本文忽略这种情况），采用TPM_MIGRATE_SCHEME方式迁移，TPM将迁移密钥的私钥K分为两部分K1，K2，其中K1为20Bytes，前4字节为私钥长度，后16Bytes为K的前16直接，K2为私钥K的后112Bytes。
4. TPM创建迁移包结构TPM_MIGRATE_ASYMKEY，设置各个field的值。
TPM_MIGRATE_ASYMKEY.payload=TPM_PT_MIGRATE
TPM_MIGRATE_ASYMKEY.usageAuth=usageAuth
TPM_MIGRATE_ASYMKEY.pubDataDigest=pubDataDigest
TPM_MIGRATE_ASYMKEY.partPrivKeyLen=Length(K2)
TPM_MIGRATE_ASYMKEY.partPrivKey=K2
TPM对TPM_MIGRATE_ASYMKEY结构进行OAEP编码，OAEP编码方法为： em=EME-OAEP-Encode(m=TPM_MIGRATE_ASYMKEY, pHash=migrationAuth, seed=K1);
TPM生成一个随机数random，然后计算d1=emÅrandom。
5. TPM使用迁移保护密钥的公钥对d1进行加密，也即是迁移授权结构TPM_MIGRATIONKEYAUTH中的TPM_PUBKEY migrationKey对d1进行加密。
6. TPM输出随机数random和MigrationBlob（outData，其实就是含有被加密的TPM_MIGRATE_ASYMKEY的TPM_KEY结构。
当外部设备、软件接收到random和MigrationBlob，剩下的工作便是要使用保护密钥对应的私钥解密得到TPM的迁移密钥的私钥K。采用软件编程的方法，使用TPM_PUBKEY migrationKey对应的私钥解密被加密的TPM_MIGRATE_ASYMKEY，然后按照前面的TPM_ConvertMigrationBlob的方法进行OAEP解码，将两部分私钥组合得到被迁移TPM密钥的私钥K。有了TPM迁移密钥的公私钥对，其他设备、软件使用TPM的密钥就不在话下。
上述方法表明只有拥有TPM Owner的权限，TPM内部受保护的密钥通过迁移机制技术上完全可以获得明文私钥。因此TPM的可迁移密钥在满足密钥互操作性的同时，实际上也降低了其安全保护强度。
17:48 |添加评论 |固定链接 |写入日志 |可信计算
5月20日
TPM互操作分析（一）
本文讨论的TPM互操作不是指TPM之间的数据、密钥共享、迁移、操作规范，而是专门讨论TPM与外部设备、软件之间的密钥互操作，也即是TPM的用户密钥能够供其他设备、软件使用，其他设备、软件的密钥能够导入TPM进行操作。
按照可信计算理论，TPM是整个平台的信任根，而我们在讨论互操作时而是将TPM看做一个普通的密码设备来分析。从TPM的规范来看，TPM试图做到能够保护重要的密钥和数据，因此设计时TPM的密钥树层层加密保护，而存储根密钥存放在TPM内部且不可导出。从这一体系可以看出TPM对密钥管理是一个封闭的黑盒，管理自身生成的密钥，一旦允许密钥的导入/导出，特别是TPM内部的存储密钥的导出，那么TPM的存储保护将没有任何安全性可言。
然而在TPM 1.2规范中提供了密钥迁移功能，实现TPM和TPM之间的密钥迁移，我们的思路是能够使用TPM的迁移机制把外部设备、软件密钥导入TPM内部使用，将TPM内部密钥导出供其他设备、软件使用。TPM的迁移机制能否解决TPM与外部的迷药互操作的问题，我们将进行严密的技术分析。
本部分关注的是外部密钥导入TPM内部的操作技术问题，TPM提供了TPM_ConvertMigrationBlob实现密钥的迁移导入TPM内部，首先来分析它的迁移实现方法。
1.父密钥PravateKey解密inData（结构为TPM_KEY12），解密后的数据，其中受保护的域定义为d1
2.使用输入的random异或d1, o1=d1Årandom，得到的o1就是一个TPM_MIGRATE_ASYMKEY结构的OAEP编码。(random是生成migrationBlob由TPM内部生成，然后输出)
o1 = EME-OAEP-Encode(m=TPM_MIGRATE_ASYMKEY, pHash=migrationAuth, seed=K1);
3.对o1进行EME-OAEP-DECODE就得到TPM_STORE_ASYMKEY数据结构d2
将OAEP编码前的seed（=K1）和TPM_STORE_ASYMKEY.partPrivKey（=K2）两者结合就得到完整的私钥SK。
4.创建TPM_STORE_ASYMKEY数据结构s, 设置s各个field
Set s -> payload = TPM_PT_MIGRATE
Set s -> usageAuth = d2 -> usageAuth
Set s -> migrationAuth = pHash
Set s -> pubDataDigest = d2 -> pubDataDigest
Set s -> privKey = SK
5.使用TPM的父密钥对TPM_STORE_ASYMKEY数据结构加密输入wrappedBlob。
对TPM迁移的过程详细分析后，下面探讨如何构造migrationBlob的方法，如果能够构造出一个迁移包，那么就能按照TPM_ConvertMigrationBlob的方法导入外部密钥。对于生成迁移包的过程，我们可以通过上述步骤逆向构建migrationBlob。
对于外部用户设备、软件所拥有的非对称密钥K，K的密钥长度、类型都必须满足TPM的要求。
1. 构造TPM_KEY12数据结构，依次设置各项值
typedef struct tdTPM_KEY12{
TPM_STRUCTURE_TAG tag;
UINT16 fill;
TPM_KEY_USAGE keyUsage;
TPM_KEY_FLAGS keyFlags;
TPM_AUTH_DATA_USAGE authDataUsage;
TPM_KEY_PARMS algorithmParms;
UINT32 PCRInfoSize;
BYTE* PCRInfo;
TPM_STORE_PUBKEY pubKey;
UINT32 encDataSize;
[size_is(encDataSize)] BYTE* encData;
//encData就是由父密钥公钥加密的数据结构（TPM_STORE_ASYMKEY 或 TPM_MIGRATE_ASYMKEY ）
//This SHALL be an encrypted  TPM_STORE_ASYMKEY structure //TPM_MIGRATE_ASYMKEY structure
} TPM_KEY12;
计算摘要值pubDataDigest，pubDataDigest是TPM_KEY12结构中除TPM_KEY.encSize和TPM_KEY.encData之外的Hash值。如果不知道TPM_KEY12中各项参数不知道如何设置，可以调用TPM创建密钥保存输出的TPM_KEY12结构，照着填写。
2. 首先将私钥SK分为两部分K1,K2，按照TPM的数据结构TPM_MIGRATE_ASYMKEY依次填充各项。
typedef struct tdTPM_MIGRATE_ASYMKEY {                // pos   len      total
TPM_PAYLOAD_TYPE payload;                       //   0     1         1
TPM_SECRET usageAuth;                                //   1    20         21
TPM_DIGEST       pubDataDigest;                           //  21    20         41
UINT32 partPrivKeyLen;                                  //  41     4         45
[size_is(partPrivKeyLen)] BYTE* partPrivKey;    //  45   112-127  157-172
} TPM_MIGRATE_ASYMKEY;
设置
TPM_MIGRATE_ASYMKEY.payload=TPM_PT_MIGRATE
TPM_MIGRATE_ASYMKEY.usageAuth=usageAuth
TPM_MIGRATE_ASYMKEY.pubDataDigest=pubDataDigest
TPM_MIGRATE_ASYMKEY.partPrivKeyLen=Length(K2)
TPM_MIGRATE_ASYMKEY.partPrivKey=K2
3. 对TPM_MIGRATE_ASYMKEY结构进行OAEP编码，OAEP编码方法为： o1=EME-OAEP-Encode(m=TPM_MIGRATE_ASYMKEY, pHash=migrationAuth, seed=K1);
生成一个随机数random，然后计算d1=o1Årandom。
4.使用TPM内部用来保护迁移密钥的存储密钥ParentKey的公钥加密d1，具体方法是获取ParentKey的公钥，然后在外部编程使用公钥加密d1。可以参考TPM_Bind加密的外部软件实现，然后将加密结果设置TPM_KEY12.encData和TPM_KEY12.encDataSize项。
5.最后输出的TPM_KEY12就是migrationBlob
按照上述方法就能够将外部设备、软件的非对称密钥导入TPM内部使用。因此采用TPM的迁移机制能够实现外部密钥的导入，在外部按照本文中提供的构建migrationBlob的办法，然后在驱动TPM执行TPM_ConvertMigrationBlob就能成功导入密钥，随后的外部密钥在TPM内部使用也是显而易见的。总之，TPM的密钥互操作中，采用迁移机制从外部到TPM这个方向技术上可行的。
11:33 |添加评论 |阅读评论 (1) |固定链接 |写入日志 |可信计算
5月12日
基于TPM的可信数据分发方法
TPM平台生成保护数据、软件分发的密钥K，K一般都是不可迁移密钥，而且还与特定的平台配置或安全属性绑定。TPM使用AIK密钥对密钥K进行Certify，将认证信息传输到Distributor（数据、软件、密钥传输分发端），Distributor验证分发密钥K，由于K是经过AIK认证，因此可以验证TPM身份，还可以知道K绑定的平台配置和属性，进一步确保Distributor分发的数据在该配置或属性条件下才能使用。然后使用K的公钥加密待分发的软件、数据，或可迁移的密钥；也可以采用对称密钥k加密数据、软件等，然后K加密保护会话密钥k，为传输的数据生成消息认证码以此保证数据传输的完整性。Receiver接收到数据后，TPM加载密钥K，使用K的私钥解密数据。
上述过程简记为：
Receiver：TPM_CreateWrapKey, K bind with configuration or property
TPM_CertifyKey(AIK, K)
Receiver--->Distributor：Kpub, Kcert_info
Distributor：Verify K, AIK
C=Encrypt(Kpub, data)
Receiver--->Distributor：TPM_LoadKey(K)
data=Decrypt(Kpriv, C), when K is conformed to predefine configuration and property.
这种常用于使用控制数据分发、TPM密钥分发（可迁移密钥迁移到TPM平台）、软件分发（软件在Certified的密钥保护下分发数据，也即是公钥加密，NM的密钥解密数据），与普通分发相比具有如下优势： 1.认证了TPM的身份，确保只有指定的TPM才能解密分发数据；
2.限制了分发数据、软件、密钥在Receiver端的使用条件。
17:12 |添加评论 |固定链接 |写入日志 |可信计算
11月17日
可信计算相关书籍(zt from TCG)
Title: Autonomic and Trusted Computing Authors: Laurence T. Yang, Hai Jin, Jianhua Ma, Theo Ungerer Publisher: Springer ISBN: 3-540-38619-X
Title: A Practical Guide to Trusted Computing Authors: David Challener, Kent Yoder, Ryan Catherman, David Safford, Leendert Van Doorn Publisher: IBM Press ISBN: 0-13-239842-7
Title: Trusted Computing Author: Chris Mitchell Publisher: IEEE ISBN: 0-86341-525-3
Title: Trusted Platform Module Basics - Using TPM in Embedded Systems Author: Steven Kinney Publisher: Newnes ISBN: 0-7506-7960-3 Japanese:http://www.amazon.co.jp/exec/obidos/ASIN/4434118943/insightintl-22
Title: The Intel Safer Computing Initiative Author: David Grawrock Publisher: Intel Press ISBN: 0-9764832-6-2
Title: Trusted Computing - Challenges and Applications Authors: Peter Lipp, Ahmad-Reza Sadeghi, Klaus-Michael Koch Publisher: Springer (Not Yet Released) ISBN: 978-3-540-68978-2
Title: Trusted Computing Platforms Author: Siani Pearson Publisher: Hewlett-Packard Company ISBN: 0-13-009220-7
Title: Trusted Computing Platforms Author: Sean W. Smith Publisher: Springer ISBN: 0-387-23916-2
16:51 |添加评论 |固定链接 |写入日志 |可信计算
可信计算资源和开发者工具(zt from TCG)
Atmel ·    Embedded Development Kit for CryptoController™ - Atmel's Trusted Platform Module (TPM) Kit for Securing for Non-PC, Embedded Applicationshttp://www.atmel.com/products/embedded/default.asp EMSCB Project ·    The EMSCB Project:http://www.emscb.org Free Radius ·    The FreeRadius Project:http://www.freeradius.org IBM ·    TrouSerS o   Free Open source SDK available for Linux TSS:http://sourceforge.net/projects/trousers ·    OpenCryptoKi with TPM token:http://sourceforge.net/projects/opencryptoki ·    Open Platform Trust Service: OSS implementation of TCG Platform Trust Services (PTS): http://sourceforge.jp/projects/openpts/ ·    Integrity Measurement Architecture (IMA) provides runtime measurements and attestation for Linux o   IMA Project:http://domino.research.ibm.com/comm/research_people.nsf/pages/sailer.ima.html o   IMA Extended Description:http://domino.research.ibm.com/comm/research_projects.nsf/pages/ssd_ima.index.html iComputing Enviornment ·    iCe Project:http://sourceforge.jp/projects/ice/ Infineon Technologieshttp://www.infineon.com/cms/en/product/channel.html?channel=ff80808112ab681d0112ab692060011a Free SDK available for: ·    Windows TSS and for Enterprise Installation and Administration Kit ·    Linux TSS 1.2 and programming examples upon request Insight International ·    SDK - TAL(TPM Access Library):http://www.insight-intl.com/jigyou/sec/TPM_TAL.html ·    Tool - TRS (TPM Remote access System):http://www.insight-intl.com/jigyou/sec/TPM_ACT.html Libtnc ·    Libtnc Project:https://sourceforge.net/projects/libtnc ·    Libtnc Downloads:http://sourceforge.net/project/showfiles.php?group_id=168708 Linux Basic Security Modules ·    Linux Basic Security Modules Project:http://sourceforge.jp/projects/lbsm/ Massachusetts Institute of Technology (MIT) ·    TPM / J0.3 User's Guide:http://projects.csail.mit.edu/tc/tpmj/UsersGuide.html ·      Microsoft ·    Free Information for using TBS:http://technet.microsoft.com/en-us/library/cc734063.aspx NTRU Cryptosystems, Inc. ·    For fee SDK information of Java- with PKCS#11:http://www.ntru.com/ OpenSEA Alliance ·    OpenSEA 802.1X supplicant:http://www.openseaalliance.org OpenTC Project (EU funded) ·    OpenTC Research & Development Project:http://www.opentc.net/ Research Center for Information Security (RCIS) ·    VMKnoppix LiveCD with support for Trusted Boot and many tools for Trusted Computing:http://www.rcis.aist.go.jp/project/knoppix/vmknoppix/index-en.html Sirrix AG Security Technologies ·    TrustedGRUB:http://projects.sirrix.com/trustedgrub ·    TPM Manager:http://projects.sirrix.com/tpmmanager Software-based TPM Emulator for Unix ·   http://tpm-emulator.berlios.de/ - Xen has a variant of this TPM emulator embedded in it Technical University of Darmstadt ·    TPM4Java:http://tpm4java.datenzone.de/trac ·      Tsukuba Open Framework for Using Grid Technology (TOFU-G) ·    TOFU-G Grid Framework Project:http://sourceforge.jp/projects/tofu/ Trusted Boot ·    Trusted Boot (tboot) is an open source, pre- kernel/VMM module that uses Intel(R) Trusted Execution Technology (Intel(R) TXT) to perform a measured and verified launch of an OS kernel/VMM o   tboot Project:http://sourceforge.net/projects/tboot/  and http://tboot.sourceforge.net/  o   tboot Downloads: http://sourceforge.net/project/showfiles.php?group_id=205557 University of Applied Arts and Sciences in Hannover, Germany (FHH) ·    University of Applied Arts and Sciences in Hannover (FHH):http://tnc.inform.fh-hannover.de University of Bochum ·    Current Projects - TPM support from the Open Source world:http://www.trust.rub.de/home/current-projects/ ·    Concluded Projects:http://www.trust.rub.de/home/concluded-projects/ University of Graz ·    Trusted Java Project:http://sourceforge.net/projects/trustedjava/ andhttp://trustedjava.sourceforge.net/ ·      o   100% in Java implemented TSS (jTSS) o   JNI wrapper for the C based TrouSerS (jTSS Wrapper) o   set of demonstration code for using the jTSS (jTpmTools) o   library to create TC certificates (TCcert) o   very basic PrivacyCA demo ·    SR 321: Trusted Computing API for Java:https://jsr321.dev.java.net/ Wave Systems ·    Free evaluation version and sample code for using TPM via MSCAPI:http://techsupport.wavesys.com/crmrequest/trial.aspx?product=CSP ·    TCG Enabled Toolkit:http://wave.com/products/toolkit.asp
16:47 |添加评论 |阅读评论 (1) |固定链接 |写入日志 |可信计算
10月29日
第三届中国可信计算年会纪要
2008年10月28日第三届可信计算年会在郑州解放军信息工程大学紫荆山宾馆召开。会议首先由与会领导致开幕词，包括国密局、科技部、工信部和解放军密管局等领导纷纷致辞，预祝会议圆满成功。然后便是会议的重要内容—特邀专家对可信计算发展状态和问题做学术报告。
学术报告阶段，沈昌祥院士首先从可信计算的标准的角度，指出中国可信计算发展的战略步骤：打基础、构主体、搞配套，可信计算标准的制定是打基础步骤的重中之重，他呼吁与会领导和专家团结协作，抛弃差异专注于中国可信计算标准TPCM的制定。但是目前我国可信计算标准已经取得了一定成果，特别是TCM标准已经非常成熟，打基础阶段已经完成，重点应放在构主体阶段。
信息安全国家重点实验室主任冯登国研究员，对国内外可信计算的发展动态，概述和分析了当前我国可信计算发展所面临的问题与挑战。从理论发展、技术应用、产业发展、国家政策等不同层面阐释现阶段面临的重要问题。理论方面，目前可信计算缺乏成熟、完善的理论模型，且技术超前于理论，这方面的问题得到了广大与会专家的共识。技术方面目前可信计算还处于飞速发展阶段，在信任根、封装存储、远程证明、应用方面，存在很多关键技术问题，这些关键问题必将成为未来可信计算学术研究的重点。产业发展方面，TPM/TCM芯片、TSS等都非常成型，在可信计算应用推广上还停滞不浅。国家政策方面，呼吁在研究资金支持、采购政策、对国外产品的执法力度等应该予以重视。
第三个报告是武汉大学张焕国教授，他汇报了武汉瑞达公司的产品成果和TPM的应用情况。武汉大学团队已经研制出遵循TPCM规范的TPM芯片，TPCM规范改变了现有计算机的启动顺序，TPM首先供电控制计算机，第一条指令由TPM执行，尽管增强了TPM的主动控制性，但这与现有计算机体系不兼容。武汉大学的研究成果还是非常全面的，包括可信PDA、可信计算在中国网格、云计算方面的应用。可信计算测评武大也做了部分工作，TPM/TCM标准符合性测试还不完善，当信任链测试方面，这方面成果还是值得借鉴，针对HP、Dell、IBM安全PC的信任链测试。
随后便是解放军工程大学的教授徐开勇对可信计算应用的一些思考，产业界代表中芯集成、武汉瑞达技术专家的报告。
总之这次会议还是比较成功的，汇集了国内可信计算方面的研究成果，对于未来我国可信计算产业和研究的发展具有巨大的促进。
18:08 |添加评论 |固定链接 |写入日志 |可信计算
3月10日
Xen上的miniOS
在Xen上可以运行的最小OS，该miniOS直接用汇编程序编写，实现了Xen的hypercall的调用。下面是它的实现代码：
# helloworld.s
.section __xen_guest
.ascii "GUEST_OS=MyOS"
.ascii ",XEN_VER=xen-3.0"
.ascii ",HYPERCALL_PAGE=0x2"
.ascii ",LOADER=generic"
.ascii ",PT_MODE_WRITABLE"
.byte 0
.text   # text section为可执行的程序代码(executable program code)
.globl _start # Guest OS的入口为_start
_start:
cld  #cld(Clear Decimal Flag) 设置ALU为二进制模式
#设置hypercall 参数
movl $18, %eax # __Hypervisor_console_io
movl $0, %ebx # CONSOLEIO_write
movl $hello_message_len, %ecx # buffer length
movl $hello_message, %edx # buffer virtual address
int $0x82 #使用int $0x82执行hypercall
#调用关机和关闭电源hypercall
movl $6, %eax # __Hypervisor_sched_op_compat
movl $2, %ebx # SCHEDOP_shutdown
movl $0, %ecx # SHUTDOWN_poweroff
int $0x82
hang:
jmp hang # shouldn't get here
.data  # 数据段(data section)
hello_message: .ascii "This is the hello world program.\n"
hello_message_len = . -hello_message  #hello消息的长度，.表示当前offset
编译时使用的Makefile为
helloworld: helloworld.s
as -o helloworld.o -a=helloworld.l helloworld.s
ld -Ttext 0x100000 -o helloworld.elf helloworld.o
该虚拟机的配置文件为
kernel = "helloworld.elf"
memory = 32
name = "HelloWorld"
on_crash = 'destroy' #当domain crash时指定guest的行动(behaviour)
8:40 |添加评论 |阅读评论 (2) |固定链接 |查看引用通告 (1) |写入日志 |可信计算
2月14日
虚拟技术的优势总结
虚拟技术的两大特点： 1.层次抽象(layers abstraction)减少了系统的复杂性，便于对资源的管理和多路复用，这种系统结构的层次性抽象能有效的将系统任务分配到不同的层次中实现，增强了系统的安全性。 2.应用分解(disaggregation of application)将不同的应用移到不同的虚拟机中，以往是全部应用放置在同一操作系统中，这导致了高层策略的复杂性。或者将应用程序放置在不同的物理系统中，这限制了整个系统应用的信息流控制。而应用分解到虚拟机减少了策略的复杂性，便于虚拟机监控层控制虚拟机间的信息流。   虚拟技术的优势 1           虚拟技术使得软件消费者而言，不需要更多的关注软件整个运行的堆栈和周边环境，不同的应用程序需要相互冲突的库的支持也不在称为关注点。（可以将这些应用放在不同的虚拟机中运行） 2           虚拟技术有更强的资源管理能力，增加了硬件的利用率，但并不增加多个应用相互影响的风险。 3           实时迁移(live migration)，能够在跨物理硬件平台实时的迁移虚拟机。   虚拟机的用途        虚拟机良好的隔离性以及对资源的高度整合性，使得其在如今互联网高速发展的背景下有着广阔的前景和应用空间。        由虚拟机技术实现的各个应用之间的完全隔离在服务器领域具有尤其重要的意义，同时虚拟机技术也可以使得企业，高校或研究所可以在不必布置大量物理计算机的情况下实现大规模的计算机网络以从事生产及研究例如网络及网络应用研究，操作系统核心软件的开发和用户操作系统的开发等。
10:24 |添加评论 |固定链接 |写入日志 |可信计算
9月8日
SW-TPM论文的思考
昨天读了普林斯顿大学电子工程系Najwa Aaraj等作者在2007年欧洲自动化和测试会议(Design, Automation & Test in Europe Conference & Exhibition)上的论文《Energy and Execution Time Analysis of a Software-based Trusted Platform Module》，让我颇受启发，似乎开始明白了怎么作研究，怎么作学问，怎么做人。
整篇论文以详尽的数据和实际应用测试，探索了TPM，特别是SW-TPM在嵌入式系统中应用问题，论文的每个数据表格、实验测试概述，无不浸透着作者劳动的结晶。作者对SW-TPM在可信引导、安全存储、VOIP应用、安全Web浏览应用（SSL协议）等几大应用场景中，进行了SW-TPM的常用命令的执行时间、耗费的能量进行了测试和计算。我也曾做作TPM命令规范研究、可信引导等开发，他们这项工作需要耗费多大的精力是可想而知的。作者最后以充分的论据得出了TPM在嵌入式环境应用结论，使用物理TPM不适合嵌入式环境，SW-TPM是一个有价值的替代选择，SW-TPM的代价适用于嵌入式系统的某些应用，推荐使用基于ECC的SW-TPM，它能更好的减少TPM执行时间的能量消耗。ECC-TPM能够减少SW-TPM 6.75倍的能量消耗，减少10.75倍的执行时间。
该篇文章没有深奥的理论，但是文中所显露出的作者扎实的研究工作确实令人钦佩。好的研究成果必定是辛勤劳动的结晶，胡编乱造，故弄玄虚，东拼西凑的论文是不屑一故的。艺术家只有不断提炼、升华，才能出现优秀的艺术作品，科学家只有对科学问题反复思考，重复实验才能有好的科研成果。劳动创造价值，智慧提升价值，永恒的价值才能不朽。
劳动+智慧======>价值---->时间检验=======>不朽成就
20:16 |添加评论 |阅读评论 (2) |固定链接 |写入日志 |可信计算
可信计算与PKI证书、密钥研究
经过最近对TPM产生的密钥和PKI中使用的公私钥进行分析，完成了TPM产生的密钥和PKI中的密钥结构的转换，为TPM生成了AIK证书。该项工作将TPM密钥、openssl密钥、JCE密钥和Keystore等关联起来，能够进行相互转换，建立起了通用的算法库和TPM计算的桥梁，该项工作现已完成TPM密钥转换openssl和JCE识别的密钥结构，并且为TPM颁发了AIK证书。下面是TPM密钥与Java密钥转换的代码：
package lois.tcwg.attestation.tpm.struct;
import java.security.*;
import java.security.spec.X509EncodedKeySpec;
import org.bouncycastle.asn1.*;
import lois.tcwg.attestation.tpm.TPMConst;
import lois.tcwg.attestation.tpm.TPMIOBase;
import lois.tcwg.attestation.util.ByteArrayUtil;
import lois.tcwg.attestation.util.Debug;
/*
typedef struct tdTPM_KEY{
TPM_STRUCT_VER ver;
TPM_KEY_USAGE keyUsage;
TPM_KEY_FLAGS keyFlags;
TPM_AUTH_DATA_USAGE authDataUsage;
TPM_KEY_PARMS algorithmParms;
UINT32 PCRInfoSize;
BYTE* PCRInfo;
TPM_STORE_PUBKEY pubKey;
UINT32 encDataSize;
[size_is(encDataSize)] BYTE* encData;
} TPM_KEY;
*/
public class TPM_KEY implements TPMIOBase {
public static final short TPM_SIGNING_KEY = 0x10;
public static final short TPM_ENCRYPTION_KEY = 0x11;
public static final short TPM_BINDING_KEY = 0x14;
public static final short TPM_LEGACY_KEY = 0x15;
byte[] tpmkey_data; // tpmkey_data is BE
int tpmkey_data_len;
// /////////////////////////////////////////
int ver; // default {0x01, 0x01, 0x00, 0x00}
/*
* byte[4] ={byte major = 1; byte minor = 1; byte revmajor = 0; byte
* revminor = 0; }
*/
short keyUsage;
// Signing Key 0x0010
// Encryption Key 0x0011
// Blinding Key 0x0014
// Legacy Key 0x0015
int keyFlags;
boolean authDataUsage;
// TPM_KEY_PARMS
int algorithmID; // default RSA 0x00000001
short encScheme;
short sigScheme;
int parmSize; // rsaKeyParmsSize default 12
// TPM_RSA_KEY_PARMS
int keyBitLength; // default 2048
int numPrimes;
int exponentSize; // 0 mean default exponents;
byte[] exponent;
int PCRInfoSize; // default 0
byte[] PCRInfo = null; // default NULL, it has nothing with PCR
// TPM_STORE_PUBKEY
int keyLength;
byte[] key; // key is modulus when alogrithm is RSA.
// Encrypted PrivateKey
int encDataSize;
byte[] encData;
private void defaultKeyParam()
{
this.ver = getVersion();
this.keyFlags = 0;
this.algorithmID = 0x00000001;
this.encScheme = 0x03;
this.sigScheme = 0x02;
this.parmSize = 12;
this.keyBitLength = 2048;
this.numPrimes = 2;
this.exponentSize = 0;
this.keyLength = 0;
this.PCRInfoSize = 0;
this.encDataSize = 0;
}
// TPM_KEY Cntor
public TPM_KEY() {
tpmkey_data = new byte[TPMConst.TPM_MAXBUF_SIZE];
// default TPM_KEY param
defaultKeyParam();
this.tpmkey_data_len = genTPM_KEY();
}
public TPM_KEY(byte[] data) {
this();
System.arraycopy(data, 0, this.tpmkey_data, 0, data.length);
this.tpmkey_data_len = parseTPM_KEY(this.tpmkey_data, 0);
}
public TPM_KEY(TPM_KEY key) {
this(key.toBytes());
}
// TPM_KEY important parameter setting
// keyType {sign, bind, encrypt, legacy}
public TPM_KEY(short keyType, boolean isAuth, boolean isMig) {
tpmkey_data = new byte[TPMConst.TPM_MAXBUF_SIZE];
// default TPM_KEY param
defaultKeyParam();
switch (keyType) {
case TPM_SIGNING_KEY:
this.keyUsage = 0x10;
break;
case TPM_ENCRYPTION_KEY:
this.keyUsage = 0x11;
break;
case TPM_BINDING_KEY:
this.keyUsage = 0x14;
break;
case TPM_LEGACY_KEY:
this.keyUsage = 0x15;
break;
default:
this.keyUsage = 0x15;
break; // default legacy key
}
if (isAuth) {
this.authDataUsage = true;
} else {
this.authDataUsage = false;
}
if (isMig) {
this.keyFlags |= 0x00000002;
}
this.tpmkey_data_len = genTPM_KEY();
}
// Get/Set Serail function
public int getTPMKeyLength() {
return this.tpmkey_data_len;
}
public short getKeyUsage() {
return this.keyUsage;
}
public boolean setKeyUsage(short keyUsage) {
switch (keyUsage) {
case TPM_SIGNING_KEY:
case TPM_ENCRYPTION_KEY:
case TPM_BINDING_KEY:
case TPM_LEGACY_KEY:
this.keyUsage = keyUsage;
return true;
default:
return false; // keyUsage is invalid
}
}
public int getKeyFlag() {
return this.keyFlags;
}
public void setKeyFlag(boolean isMig) {
if (isMig) {
this.keyFlags |= 0x00000002;
} else {
this.keyFlags = 0;
}
}
public int getAlgorithmID() {
return this.algorithmID;
}
public short getEncScheme() {
return this.encScheme;
}
public short getSigScheme() {
return this.sigScheme;
}
private int getVersion() {
byte[] version = new byte[4];
version[0] = 1; // major
version[1] = 1; // minor
version[2] = 0; // rev_major
version[3] = 0; // rev_minor
return ByteArrayUtil.ReadUInt32LE(version, 0);
}
private int parseTPM_KEY(byte[] data, int offset) {
int off = 0;
this.ver = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
this.keyUsage = ByteArrayUtil.ReadUInt16LE(data, offset + off);
off += 2;
this.keyFlags = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
this.authDataUsage = ByteArrayUtil.ReadBoolean(data, offset + off);
off += 1;
this.algorithmID = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
this.encScheme = ByteArrayUtil.ReadUInt16LE(data, offset + off);
off += 2;
this.sigScheme = ByteArrayUtil.ReadUInt16LE(data, offset + off);
off += 2;
this.parmSize = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
this.keyBitLength = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
this.numPrimes = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
this.exponentSize = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
if (this.exponentSize > 0) {
this.exponent = ByteArrayUtil.ReadBytes(data, offset + off,
this.exponentSize);
off += exponentSize;
}
this.PCRInfoSize = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
if (this.PCRInfoSize > 0) {
this.PCRInfo = ByteArrayUtil.ReadBytes(data, offset + off,
this.PCRInfoSize);
off += PCRInfoSize;
}
this.keyLength = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
if (this.keyLength > 0) {
this.key = ByteArrayUtil.ReadBytes(data, offset + off,
this.keyLength);
off += keyLength;
}
this.encDataSize = ByteArrayUtil.ReadUInt32LE(data, offset + off);
off += 4;
if (this.encDataSize > 0) {
this.encData = ByteArrayUtil.ReadBytes(data, offset + off,
this.encDataSize);
off += encDataSize;
}
return off;
}
private int genTPM_KEY() {
int offset = 0;
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.ver);
offset += 4;
ByteArrayUtil.WriteUInt16(this.tpmkey_data, offset, this.keyUsage);
offset += 2;
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.keyFlags);
offset += 4;
ByteArrayUtil
.WriteBoolean(this.tpmkey_data, offset, this.authDataUsage);
offset += 1;
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.algorithmID);
offset += 4;
ByteArrayUtil.WriteUInt16(this.tpmkey_data, offset, this.encScheme);
offset += 2;
ByteArrayUtil.WriteUInt16(this.tpmkey_data, offset, this.sigScheme);
offset += 2;
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.parmSize);
offset += 4;
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.keyBitLength);
offset += 4;
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.numPrimes);
offset += 4;
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.exponentSize);
offset += 4;
if (this.exponentSize > 0) {
ByteArrayUtil.WriteBytes(this.tpmkey_data, offset, this.exponent);
offset += exponentSize;
}
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.PCRInfoSize);
offset += 4;
if (this.PCRInfoSize > 0) {
ByteArrayUtil.WriteBytes(this.tpmkey_data, offset, this.PCRInfo);
offset += PCRInfoSize;
}
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.keyLength);
offset += 4;
if (this.keyLength > 0) {
ByteArrayUtil.WriteBytes(this.tpmkey_data, offset, this.key);
offset += keyLength;
}
ByteArrayUtil.WriteUInt32(this.tpmkey_data, offset, this.encDataSize);
offset += 4;
if (this.encDataSize > 0) {
ByteArrayUtil.WriteBytes(this.tpmkey_data, offset, this.encData);
offset += encDataSize;
}
this.tpmkey_data_len = offset;
return this.tpmkey_data_len;
}
public byte[] toBytes() {
byte data[] = new byte[this.tpmkey_data_len];
System.arraycopy(this.tpmkey_data, 0, data, 0, this.tpmkey_data_len);
return data;
}
public void fromBytes(byte[] source, int offset) {
this.tpmkey_data_len = parseTPM_KEY(source, offset);
System.arraycopy(source, offset, this.tpmkey_data, 0,
this.tpmkey_data_len);
}
public String toHexString() {
byte data[] = new byte[this.tpmkey_data_len];
System.arraycopy(this.tpmkey_data, 0, data, 0, this.tpmkey_data_len);
return ByteArrayUtil.toHexString(data);
}
// TPM_KEY convert into PublicKey object
// EncodePublicKey(SubjectPublicKeyInfo) ==> PublicKey (Java Object)
public PublicKey convertPublicKey()
{
byte[] encodedPublicKey = convertSubjectPublicKeyInfo();
PublicKey pubKey = null;
X509EncodedKeySpec pubKeySpec = new X509EncodedKeySpec(encodedPublicKey);
try
{
KeyFactory kf = KeyFactory.getInstance("RSA");
pubKey = kf.generatePublic(pubKeySpec);
}
catch(Exception e)
{
Debug.println("KeyFactory Exception");
e.printStackTrace();
}
return pubKey;
}
// TPM_KEY ==> SubjectPublicKeyInfo
public byte[] convertSubjectPublicKeyInfo()
{
//   SubjectPublicKeyInfo ::= SEQUENCE {
//      algorithm AlgorithmIdentifier,
//      subjectPublicKey BIT STRING }
//
//    AlgorithmIdentifier ::= SEQUENCE {
//      algorithm OBJECT IDENTIFIER,
//      parameters ANY DEFINED BY algorithm OPTIONAL }
// SubjectPublicKeyInfo basic elements
DERInteger exponent = new DERInteger(new Integer(0x10001)); // e
DERInteger modulus = null; // from TPM_KEY
DERSequence RSAPublicKey = null;
DERBitString subjectPublicKey = null;
DERSequence SubjectPublicKeyInfo = null;
// get modulus from TPM_KEY
byte[] byteModulus = this.key;
modulus = new DERInteger(byteModulus);
// -->RSAPublicKey
ASN1EncodableVector v = new ASN1EncodableVector();
if(modulus != null)
v.add(modulus);
if(exponent != null)
v.add(exponent);
RSAPublicKey = new DERSequence(v);
// -->subjectPublicKey
subjectPublicKey = new DERBitString(RSAPublicKey);
// -->AlgorithmIdentifier
DERSequence AlgorithmIdentifier = null;
String AlgOId = "1.2.840.113549.1.1.5"; //sha1withRSAEncryption
DERObjectIdentifier algorithm = new DERObjectIdentifier(AlgOId);
DERNull optional = new DERNull();
ASN1EncodableVector v1 = new ASN1EncodableVector();
v1.add(algorithm);
v1.add(optional);
AlgorithmIdentifier = new DERSequence(v1);
// -->SubjectPublicKeyInfo
ASN1EncodableVector v2 = new ASN1EncodableVector();
v2.add(AlgorithmIdentifier);
v2.add(subjectPublicKey);
SubjectPublicKeyInfo = new DERSequence(v2);
return SubjectPublicKeyInfo.getDEREncoded();
}
}
20:13 |添加评论 |固定链接 |写入日志 |可信计算
8月7日
TPMKit及其影响
由印度NVLab的Nitin Kumar和Vipin Kumar研发的TPMKit主要针对的是Vista的BitLocker机制，能够绕过Vista BitLocker获得Vista的系统权限。TPMKit又称之为Vbootkit，bootkit是Windows Vista's bootkit，用于截获Vista的启动过程。Vbootkit测试在Vista RC1, RC2上完成，对于其他Vista 32bit系统Vista的测试依然有效。 可以看出由TPM构建整个可信系统还存在一定的问题，但上述攻击并不表示可信计算的基石TPM不牢固，只是在构建可信计算平台时系统层出现的漏洞。TPM安全芯片被攻陷，那才能彻底的颠覆整个可信计算体系。由此可知，可信计算在实际应用中还会出现或多或少的问题，但是总体趋势是无法阻挡的。
9:45 |添加评论 |固定链接 |写入日志 |可信计算
6月14日
NSC TPM的命令支持情况
NSC TPM的命令支持情况
经程序测试，NSC TPM 1.2支持TCG所定义的绝大部分TPM 命令，按照TCG的TPM Command规范，TPM命令共计122个，NSC TPM支持其中的101个命令，其中有21个命令不支持，这些不支持的命令主要是关于TPM Audit的命令，KeyContext，AuthContext，Maintenance的命令。命令支持情况参照下表：
TPM_ORD_OIAP(0xA) √
TPM_ORD_OSAP(0xB) √
TPM_ORD_ChangeAuth(0xC) √
TPM_ORD_TakeOwnership(0xD) √
TPM_ORD_ChangeAuthAsymStart(0xE) √
TPM_ORD_ChangeAuthAsymFinish(0xF) √
TPM_ORD_ChangeAuthOwner(0x10) √
TPM_ORD_DSAP(0x11) √
TPM_ORD_CMK_CreateTicket(0x12) √
TPM_ORD_CMK_CreateKey(0x13) √
TPM_ORD_Extend(0x14) √
TPM_ORD_PcrRead(0x15) √
TPM_ORD_Quote(0x16) √
TPM_ORD_Seal(0x17) √
TPM_ORD_Unseal(0x18) √
TPM_ORD_DirWriteAuth(0x19) √
TPM_ORD_DirRead(0x1A) √
TPM_ORD_CMK_CreateBlob(0x1B) √
TPM_ORD_CMK_SetRestrictions(0x1C) √
TPM_ORD_CMK_ApproveMA(0x1D) √
TPM_ORD_UnBind(0x1E) √
TPM_ORD_CreateWrapKey(0x1F) √
TPM_ORD_LoadKey(0x20) √
TPM_ORD_GetPubKey          (0x21) √
TPM_ORD_EvictKey(0x22) √
TPM_ORD_KeyControlOwner(0x23) √
TPM_ORD_CMK_ConvertMigration(0x24) √
TPM_ORD_MigrateKey(0x25) √
TPM_ORD_CreateMigrationBlob    (0x28) √
TPM_ORD_DAA_JOIN(0x29) √
TPM_ORD_ConvertMigrationBlob(0x2A) √
TPM_ORD_AuthorizeMigrationKey  (0x2B) √
TPM_ORD_CreateMaintenanceArchive(0x2C) ×
TPM_ORD_LoadMaintenanceArchive(0x2D) ×
TPM_ORD_KillMaintenanceFeature(0x2E) ×
TPM_ORD_LoadManuMaintPub(0x2F) ×
TPM_ORD_ReadManuMaintPub(0x30) ×
TPM_ORD_DAA_SIGN(0x31) √
TPM_ORD_CertifyKey(0x32) √
TPM_ORD_CertifyKey2(0x33) √
TPM_ORD_Sign(0x3C) √
TPM_ORD_Sealx(0x3D) ×
TPM_ORD_Quote2(0x3E) √
TPM_ORD_SetCapability(0x3F) √
TPM_ORD_ResetLockValue(0x40) √
TPM_ORD_LoadKey2(0x41) √
TPM_ORD_GetRandom(0x46) √
TPM_ORD_StirRandom(0x47) √
TPM_ORD_SelfTestFull(0x50) √
TPM_ORD_CertifySelfTest(0x52) √
TPM_ORD_ContinueSelfTest(0x53) √
TPM_ORD_GetTestResult(0x54) √
TPM_ORD_Reset(0x5A) √
TPM_ORD_OwnerClear(0x5B) √
TPM_ORD_DisableOwnerClear(0x5C) √
TPM_ORD_ForceClear(0x5D) √
TPM_ORD_DisableForceClear(0x5E) √
TPM_ORD_GetCapabilitySigned(0x64) ×
TPM_ORD_GetCapability(0x65) √
TPM_ORD_GetCapabilityOwner(0x66) √
TPM_ORD_OwnerSetDisable(0x6E) √
TPM_ORD_PhysicalEnable(0x6F) √
TPM_ORD_PhysicalDisable(0x70) √
TPM_ORD_SetOwnerInstall(0x71) √
TPM_ORD_PhysicalSetDeactivated(0x72) √
TPM_ORD_SetTempDeactivated(0x73) √
TPM_ORD_SetOperatorAuth(0x74) √
TPM_ORD_SetOwnerPointer(0x75) √
TPM_ORD_CreateEndorsementKeyPair(0x78) √
TPM_ORD_MakeIdentity(0x79) √
TPM_ORD_ActivateIdentity(0x7A) √
TPM_ORD_ReadPubek(0x7C) √
TPM_ORD_OwnerReadPubek(0x7D) √
TPM_ORD_DisablePubekRead(0x7E) √
TPM_ORD_CreateRevocableEK(0x7F) ×
TPM_ORD_RevokeTrust(0x80) ×
TPM_ORD_OwnerReadInternalPub(0x81) √
TPM_ORD_GetAuditEvent(0x82) ×
TPM_ORD_GetAuditEventSigned(0x83) ×
TPM_ORD_GetAuditDigest(0x85) ×
TPM_ORD_GetAuditDigestSigned(0x86) ×
TPM_ORD_GetOrdinalAuditStatus(0x8C) ×
TPM_ORD_SetOrdinalAuditStatus(0x8D) ×
TPM_ORD_Terminate_Handle(0x96) √
TPM_ORD_Init(0x97) √
TPM_ORD_SaveState(0x98) √
TPM_ORD_Startup(0x99) √
TPM_ORD_SetRedirection(0x9A) ×
TPM_ORD_SHA1Start(0xA0) √
TPM_ORD_SHA1Update(0xA1) √
TPM_ORD_SHA1Complete(0xA2) √
TPM_ORD_SHA1CompleteExtend(0xA3) √
TPM_ORD_FieldUpgrade(0xAA) ×
TPM_ORD_SaveKeyContext(0xB4) ×
TPM_ORD_LoadKeyContext(0xB5) ×
TPM_ORD_SaveAuthContext(0xB6) ×
TPM_ORD_LoadAuthContext(0xB7) ×
TPM_ORD_SaveContext(0xB8) √
TPM_ORD_LoadContext(0xB9) √
TPM_ORD_FlushSpecific(0xBA) √
TPM_ORD_PCR_Reset(0xC8) √
TPM_ORD_NV_DefineSpace(0xCC) √
TPM_ORD_NV_WriteValue(0xCD) √
TPM_ORD_NV_WriteValueAuth(0xCE) √
TPM_ORD_NV_ReadValue(0xCF) √
TPM_ORD_NV_ReadValueAuth(0xD0) √
TPM_ORD_Delegate_UpdateVerification(0xD1) √
TPM_ORD_Delegate_Manage(0xD2) √
TPM_ORD_Delegate_CreateKeyDelegation(0xD4) √
TPM_ORD_Delegate_CreateOwnerDelegation(0xD5) √
TPM_ORD_Delegate_VerifyDelegation(0xD6) √
TPM_ORD_Delegate_LoadOwnerDelegation(0xD8) √
TPM_ORD_Delegate_ReadTable(0xDB) √
TPM_ORD_CreateCounter(0xDC) √
TPM_ORD_IncrementCounter(0xDD) √
TPM_ORD_ReadCounter(0xDE) √
TPM_ORD_ReleaseCounter(0xDF) √
TPM_ORD_ReleaseCounterOwner(0xE0) √
TPM_ORD_EstablishTransport(0xE6) √
TPM_ORD_ExecuteTransport(0xE7) √
TPM_ORD_ReleaseTransportSigned(0xE8) √
TPM_ORD_GetTicks(0xF1) √
TPM_ORD_TickStampBlob(0xF2) √
11:37 |添加评论 |阅读评论 (1) |固定链接 |写入日志 |可信计算
TPM Monotonic Counter的测试
经测试NSC的TPM 1.2拥有4个Monotonic Counter，默认情况下无ActiveCounter，由于目前还不知到这四个基本的Counter的CounterID，所以还无法进一步读出这些Counter的默认计数值。
对于Counter的测试程序如下：
public class TPMCounterProp
{
public static TPMDriver tpmdriver;
public static void handleTPMException( TPMException e )
{
System.out.println( "TPM Exception: " + e );
System.out.println( "Occured on input: " + e.getTPMInputStruct() );
System.out.println( "Output (if any): " + e.getTPMOutputStruct() );
System.out.println( "Return Code (if any): " + e.getReturnCode() + " ("
+ TPM_RESULT.getErrorName( e.getReturnCode() ) + ")" );
//        System.out.println( "Stack trace: " );
//        e.printStackTrace();
}
public static void main(String[] args)
{
TPMUtilityFuncs.initTPMDriver();
tpmdriver = TPMUtilityFuncs.getTPMDriver();
int maxcounter;
String activecounter;
int propvalue;
try
{
System.out.println("Get TPM MaxCounter...");
maxcounter = TPMGetCapabilityFuncs.getMaxCounters();
System.out.println("MaxCounter = " + maxcounter);
System.out.println("Get TPM ActiveCounter...");
activecounter = TPMGetCapabilityFuncs.getActiveCounter();
System.out.println("ActiveCounter = 0x" + activecounter);
///         TPM其他属性测试
System.out.println("///////////////////////////////////");
System.out.println("Get TPM DIR Number...");
propvalue = TPMGetCapabilityFuncs.getCapProp(TPMConsts.TPM_CAP_PROP_DIR);
System.out.println("DIR Number = " + propvalue);
System.out.println("Get TPM MaxKeyLoadSupport...");
propvalue = TPMGetCapabilityFuncs.getCapProp(TPMConsts.TPM_CAP_PROP_MAX_KEYS);
System.out.println("MAX Key = " + propvalue);
System.out.println("///////////////////////////////////");
System.out.println("Get Session Property");
System.out.println("Get TPM MaxTransportSession...");
propvalue = TPMGetCapabilityFuncs.getCapProp(TPMConsts.TPM_CAP_PROP_MAX_TRANSESS);
System.out.println("MaxTransportSession = " + propvalue);
System.out.println("Get TPM MaxAuthorizationSession...");
propvalue = TPMGetCapabilityFuncs.getCapProp(TPMConsts.TPM_CAP_PROP_MAX_AUTHSESS);
System.out.println("MaxAuthorizationSession = " + propvalue);
System.out.println("Get TPM MaxSessionSupport...");
propvalue = TPMGetCapabilityFuncs.getCapProp(TPMConsts.TPM_CAP_PROP_MAX_SESSIONS);
System.out.println("MaxSessionSupport = " + propvalue);
System.out.println("///////////////////////////////////");
System.out.println("Get Delegation Property:");
System.out.println("Get TPM FamilyTableRow...");
propvalue = TPMGetCapabilityFuncs.getCapProp(TPMConsts.TPM_CAP_PROP_FAMILYROWS);
System.out.println("FamilyTableRow = " + propvalue);
System.out.println("Get TPM DelegationTableRow...");
propvalue = TPMGetCapabilityFuncs.getCapProp(TPMConsts.TPM_CAP_PROP_DELEGATE_ROW);
System.out.println("DelegationTableRow = " + propvalue);
System.out.println("Get NV Storage Property");
System.out.println("Get TPM MaxNVAvailiable...");
propvalue = TPMGetCapabilityFuncs.getCapProp(TPMConsts.TPM_CAP_PROP_MAX_NV_AVAILABLE);
System.out.println("NV Storage = " + propvalue);
}
catch(TPMException e)
{
handleTPMException(e);
}
}
}
11:27 |添加评论 |固定链接 |写入日志 |可信计算
4月14日
vista的bitlocker,目前最强文件加密软件(zz)
Vista BitLocker Drive Encrytion（BitLocker驱动器加密）是Vsita中的一个新功能，它为电脑提供增强的数据保护功能。
BitLocker是为了顺应用户的要求而推出的：它是为了解决数据被偷或者由于丢失而曝光，或者没做适当处理就丢弃电脑而造成的数据信息泄露等问题而开发的；它已经被紧密的整合进Windows中。
BitLocker防止盗窃者启动另外一个系统，或者运行其它黑客软件来破坏Vista中的文件和系统保护机制，或者脱机浏览存储在受保护驱动器中的文件。它是基于硬件的全盘加密，以迎合增强数据保护的需要。
这个功能可以选用信任平台模块（Trusted Platform Module,TPM）1.2来保护用户数据并确保运行Vista的电脑在关机后没被篡改。万一移动和办公企业信息用户电脑丢失或者被偷的情况下，BitLocker为他们提供增强的数据保护，并且当不需要这些数据的时候能安全的删除这些数据。
这个组组件主要是在本地用软硬结合的方式来保护我们硬盘上的数据的。现在电脑的丢失已经是很常见的事情了，有时候连放在办公室的电脑都有可能会被偷走，就更不要说笔记本电脑和平板电脑了。而如果你的电脑中存放着很敏感的资料，例如你工作单位的一些机密、你的银行账户等等这些，如果被不怀好意的人拿到的话后果可能是致命的，不知道大家有没有参加过关于这个Bitlocker的Webcast，里面就提到几个案例，因为存放着敏感资料的笔记本被盗以后导致一个公司的商业机密泄露到了它的竞争对手手中而面临倒闭，也有个人资料泄露以后导致隐私被公开或者受到要挟。而Windows XP的账户密码是非常脆弱的，懂一  点专业技术的人都能在几分钟之内破解掉它，拿到计算机里面的数据，这种攻击方法称之为离线式攻击，也就是攻击者直接接触你的电脑来实施入侵行为，所以如何保护我们硬盘中的数据特别是对笔记本电脑这类更容易丢失的电脑来说显得尤为重要。Bitlocker也就是在这样一种局面下诞生了，它采用了硬件和软件相结合的方法来保护我们硬盘中的数据。
启用了Bitlocker以后会生成两个密钥：一个存放于引导分区中；另外一个存放在主板上的一个名叫TPM的芯片里，在计算机加电的时候首先是TPM最先加载，他会和引导区中的密钥进行对比验证，通过了以后才会加载BOIS完成计算机启动过程。而如果这当中任何一个不匹配的话，比如有对这个TPM芯片作了手脚，或者是把硬盘拆下来放到别的机器中，Windows Vista将会拒绝掉密钥的释放，系统将无法启动。这个加密机制我可以毫不夸张地告诉大家，在各位的有生之年是它绝对是安全可靠的，不会被破解掉。当然，对于一些可能存在的事情，比如主板坏啦，或者需要把磁盘移动到一台新的计算机中的时候，Bitlocker也提供了恢复功能，就是在加密的时候Bitlocker会给出一个48位的恢复密钥，要求用户在做加密的时候一定要妥善的保管这个密钥，否则当遇到上面提到的这些情况时你将永远无法取回那块硬盘中的资料了。
再说TPM芯片，这是比较新的一种硬件芯片，在比较新的主板中已经有了，我也在市场上看了一下，发现已经有部分的主板和笔记本电脑都包含了这个芯片，但是包含这个芯片的台式机主板还是比较少，但是在不久这种芯片将会得到普及。
Bitlocker只能加密系统分区也就是Windows Vista所在的分区，那么其他分区的数据难道就得不到保护了吗？我们说其他分区的数据也是可以保护的，至于方法就是利用在Windows XP中就已经存在EFS，这个是一种基于用户账户的文件保护机制，也就是说它使用用户的计算机帐户对该用户的数据进行加密，在Windows XP中，使用过EFS的用户一定知道，EFS的加密是非常有效的，并且在使用的时候完全没有任何的影响，用户完全感觉不到它的存在，然而当换一个用户登录操作系统想要访问另一个账户的被加密的文档时候肯定是不可能的。但是之所以这套加密机制在Windows XP中有如形同虚设的原因就是前面提到的，Windows XP的帐户密码可以在几分钟之内被破解掉，因此EFS也就失去作用了，但是在Windows Vista中有Bitlocker来保护我们的系统分区，也就是等于保护了用户账户，攻击者在拿不到这些账户的时候是也就根本不可能拿到那些在其他分区中被EFS所保护的任何数据了。因此有了这套机制的保护，我们的硬盘就是被FBI拿到，他们拿硬盘中的数据也是没有任何办法的。
10:05 |添加评论 |固定链接 |写入日志 |可信计算
NSC TPM 1.2芯片
检查IBM 8114的NSC的TPM芯片
l         10 key slots
l         24个PCR， PCR17-PCR22初值全F，当前locality下不能extend，PCR0-PCR15都不可Reset，初值为全0。
l         TPM 1.2共计122个命令，NSC的TPM支持其中的101个命令。
l         PCR16，PCR23在当前locality下既可以reset，又可以extend，猜测PCR16，PCR23都是debug PCR。
9:55 |添加评论 |固定链接 |查看引用通告 (1) |写入日志 |可信计算
可信计算开源代码列表
Software Downloads
Grub bootloader extension issuing measurements to TPM during boot.
Code:http://sourceforge.net/projects/trousers
Installation instructions:http://trousers.sourceforge.net/grub.html
Integrity Measurement Architecture LSM patch for newer kernel versions
Code:http://sourceforge.net/projects/linux-ima
Comprehensive TPM software stack, e.g., to retrieve signatures over PCRs (Quotes)
Code:http://sourceforge.net/projects/trousers
TPM device drivers are part of the newer Linux kernels
Code:ftp://ftp.kernel.org/pub/linux/kernel
9:46 |添加评论 |固定链接 |写入日志 |可信计算
可信计算图书列表
可信计算图书列表：
《Trusted Computing Platform: Designs and Applications》--Smith，讲述了TC的早期研究背景和现有的研究动向，现已有我们译的中文版
《Trusted Computing Platforms: TCPA Technology in Context》--HP公司的研究人员出版的，内容和TCG的标准很接近，侧重于可信计算具体的实施细节。
《Trusted Computing》--Edited by Chris Mitchell，伦敦大学，可信计算研究类书。
google books该书影印版：
http://books.google.com/books?vid=ISBN0863415253&id=9iriBw2AuToC&pg=PP1&lpg=PP1&ots=mtdQUSwUD-&dq=Trusted+Computing&sig=-WmAaf18KEbfuFz7AgAYLhPZ7EA#PPA2,M1
《Practical Guide to Trusted Computing》--主要由IBM的研究人员组织编撰，2007出版
《Trusted Platform Module Basics: Using TPM in Embedded Systems》-- By Steven L. Kinney
9:41 |添加评论 |固定链接 |写入日志 |可信计算
TPM密钥授权数据的保护机制思考
TPM密钥授权数据的保护机制思考
TCG的密钥保护树模型：
(1)加载子密钥时，必须知道父密钥的授权数据
(2)使用密钥时，必须知道该密钥的授权数据
即：加载密钥userKey，必须首先加载密钥storageKey到TPM中，并且加载密钥userKey时，必须知道storageKey的授权数据。将userKey加载到TPM后，使用userKey进行加密，签名时必须知道userKey的授权数据。
TCG密钥保护模型的目标是：普通的TPM USER创建密钥，仅仅只有TPM USER才知道该密钥授权数据，只有TPM USER密钥加密数据，签名文档.
假定密钥保护树攻击方法
将定一个简单的密钥保护树，SRK--->storageKey--->userKey,
TPM OWNER知道父密钥storageKey的授权数据，那么TPM OWNER可以通过篡改数据，旁路的方式使用userKey进行加密，签名。即使是TPM USER修改了userKey的授权数据，这种攻击仍然存在。
设定: storageKey的密钥storage Key类型
具体攻击步骤
1)以KeyUsage为storage key的方式加载storageKey
2)加载userKey
3)Evict storageKey
4)修改storageKey.keyusage = 0x0014改为BindKey
5)加载storageKey, 用TPM_UnBind解密userKey的授权数据
上述攻击方法无效：
被父密钥加密的私钥部分(TPM_STORE_ASYMKEY)中含有一项TPM_DIGEST pubDataDigest; 这项TPM_KEY结构中除去
UINT32 encDataSize;
[size_is(encDataSize)] BYTE* encData;
这两项外其余数据的摘要值。
TPM使用密钥时，会计算TPM_KEY的Hash值，检查pubDataDigest。由于上述攻击4)中修改了KeyUsage,使用加载storageKey就会因为pubDataDigest检查无法通过。
9:36 |添加评论 |固定链接 |写入日志 |可信计算
3月22日
IBM的IMA实现简单剖析
IBM的IMA实现剖析
security/ima/ima_main.c实现内核启动的运行时度量，ima_measure_kernel_module度量加载的内核模块(调用do_measure_memory对内存地址空间度量，相当于度量内核模块的dump bin)，measure_file函数进行文件度量，measure_user_file接口用于度量用户空间文件。
这里以IMA度量内核文件为例：measure_file首先调用ima_lookup_measure_entry从度量队列中获取measure_entry, 再调用ima_add_measure_entry对文件进行度量和PCR_Extend，ima_add_measure_entry调用ima_add_sha_entry，再调用SHA_KEY函数度量文件,SHA_KEY函数是通过内核中SHA1算法调用实现的，不是调用TPM硬件实现SHA1算法。然后ima_add_measure_entry调用ima_extend(定义于ima.h)进行度量点PCR_Extend，IBM扩展的PCR是CONFIG_IMA_MEASURE_PCR_IDX(PCR10)，此处的ima_extend是通过TPM芯片实现的。
18:12 |添加评论 |阅读评论 (4) |固定链接 |写入日志 |可信计算
11月8日
TPM frontend driver的使用步骤
TPM frontend driver的使用步骤
qinyu
1.         定义tpmfe_device结构
TPM frontend driver的头文件tpmfe.h定义了tpmfe_device结构，外部使用frontend就必须定义tpmfe_device的实例。
struct tpmfe_device {
int (*receive)(const u8 *buffer, size_t count, const void *ptr);   //上层接收回调函数
void (*status)(unsigned int flags);
unsigned int max_tx_size;
struct tpm_private *tpm_private;
};
2.         注册/注销接收实例
在tpmfront.c中导出了tpmfe_device的注册/注销函数，通过这两个函数注册第一步定义的tpmfe_device实例。
int tpm_fe_register_receiver(struct tpmfe_device *tpmfe_dev)
void tpm_fe_unregister_receiver(void)
3.         发送/接收数据
tpmfront.c中导出了接收数据函数tpm_fe_send，使用这个函数上层应用可以向tpm frontend发送数据。
int tpm_fe_send(struct tpm_private *tp, const u8 * buf, size_t count, void *ptr)
函数调用时，函数第一个参数为tpmfe_device结构的tpm_private项。
而接收数据和发送实现不同，不是通过导出函数实现，而是由tpmfe_device的第一个域receive回调函数实现。receive函数输入参数为接收到的数据及其长度。
int (*receive)(const u8 *buffer, size_t count, const void *ptr);
21:11 |添加评论 |阅读评论 (2) |固定链接 |写入日志 |可信计算
Xen hyercall调用
Hypercall的调用流程：
1. 首先应用程序（例如：Xend）创建hypercall的命令及其参数，用pricmd_hypercall_t结构进行创建，然后ioctl操作privcmd驱动设备。
例如domain的创建hypercall：
privcmd_hypercall_t hypercall = { 0 };
hypercall.op     = __HYPERVISOR_dom0_op;
hypercall.arg[0] = (unsigned long)op;
2. Dom0内核层中提供了privcmd命令接口，privcmd通过获取ioctl操作命令，使用inline assemble将hypercall命令数据传递给Hypervisor.
3. 在Hypervisor中hypercall的调用被映射到hypercall_table表，查找到相应的hypercall entry，执行对应的hypercall函数完成操作。
21:06 |添加评论 |固定链接 |写入日志 |可信计算
Xen源代码的编译安装
Xen源代码的编译安装
qinyu
安装编译步骤
第一步：解压软件包，查看Xen源码包所带的文件；
第二步：配置内核；
linux-2.6-xen-sparse/arch/xen/configs/目录下是内核的配置文件,先设置Xen内核配置文件，可以手动，也可以通过命令配置。
第三步：编译和安装Xen；
Xen的编译需要在原有的内核代码上打补丁，这样编译出的xen内核支持虚拟技术。在编译之前，先将linux内核源码包linux-2.6.16.tar.bz2拷贝到xen根目录下（否则xen安装程序将从kernel.org上下载内核linux-2.6.16.tar.bz2进行安装）。
[root@localhost xen-3.0.2]# make all
[root@localhost xen-3.0.2]# make install
编译具体方法
第一次编译
# make KERNELS=linux-2.6-xen all     //如果不指定KERNELS，那么将编译两个内核镜像Xen0,XenU，指定KERNELS=linux-2.6-xen那么将生成一个共用的linux内核镜像vmlinuz-2.6.x-xen。在xen-3.0.2默认的是只编译一个共用内核,指定KERNEL=”linux-2.6-xen0 linux-2.6-xenU”将分别编译出Dom0,DomU内核。
（注意：编译两个内核最好的方法是直接在Makefile文件中设置KERNELS= linux-2.6-xen0 linux-2.6-xenU）
# make install
重新编译
# make linux-2.6-xen-config CONFIGMODE=menuconfig     (or xconfig)
# make linux-2.6-xen-build
# make linux-2.6-xen-install   （经测试linux-2.6-xen-build和linux-2.6-xen-install编译功能完全相同，只需使用linux-2.6-xen-install就能满足要求）
如果分两个内核编译那么执行下面的命令
# make linux-2.6-xen0-config CONFIGMODE=menuconfig     (or xconfig)
# make linux-2.6-xen0-install
# make linux-2.6-xenU-config CONFIGMODE=menuconfig     (or xconfig)
# make linux-2.6-xenU-install
为新编译的Xen内核生成ram disk文件
Depending on your config, you may need to use 'mkinitrd' to create an initial ram disk, just like a native system e.g.
# depmod 2.6.16-xen            #2.6.16-xen是xen内核版本号
# mkinitrd -v -f --with=aacraid --with=sd_mod --with=scsi_mod  /boot/initrd-2.6.16-xen.img 2.6.16-xen
两个内核可以分别制作initrd
配置grub启动项
title Xen 3.0 (XenLinux 2.6)
root (hd0,7)
kernel /boot/xen-3.0.2.gz
module /boot/vmlinuz-2.6.16-xen root=LABEL=/12 rhgb quiet selinux=0
module /boot/initrd-2.6.16-xen.img
如何在DomU中安装新内核
如果想升级DomU的内核，启动DomU后按照普通的编译升级内核的办法是无法实现的。因为DomU的Xen配置文件中指定了kernel和ramdisk是Dom0文件系统中的/boot/vmlinuz-2.6.X-xenU和/boot/initrd-2.6.X-xenU.img，DomU启动是使用这个内核启动的。要想升级DomU的内核需要将内核源码包，如内核linux-2.6.18.tar.bz2拷贝到xen根目录下，修改Makefile中的设置：KERNELS=linux-2.6.18-xenU，再这样编译xen，就会得到一个新的DomU内核，然后mount DomU的文件系统分区，将lib/modulue/2.6.18-xenU下的里边拷贝到DomU对应的文件系统中，在DomU的VM的配置文件中指定新的内核和initial ramdisk。
下载新内核源码包（这里为linux-2.6.17.tar.bz2)，将新内核放置在Xen根目录下，然后修改根目录下Makefile文件。
KERNELS ＝ linux-2.6-xenU             //单独编译出DomU的内核, 如果单独编译Dom0的内核改为linux-2.6-xen0就行了
修改buildconfigs/mk.linux-2.6-xen文件
LINUX_SERIES = 2.6
LINUX_VER   = 2.6.17
LINUX_SRCS = linux-2.6.17.tar.bz2    //解压linux-2.6.17.tar.bz2，编译时内核源码所在目录为linux-2.6.17-xenU
经过我测试，按照上诉方法将DomU内核升级到2.6.17，2.6.18都出现编译错误，原因是由于目录linux-2.6-xen-sparse下的源码和2.6.16匹配，而与2.6.17，2.6.18结合就产生了编译错误。
21:03 |添加评论 |固定链接 |写入日志 |可信计算
8月17日
xen-3.02内核编译过程解析
Xen编译时相关目录及其过程
linux-2.6.16-xen
含有Xen源代码的内核目录,是拷贝ref-linux-2.6.16目录中的代码，然后使用linux-2.6-xen-sparse目录构建源码树得到，使用的是脚本mkbuildtree实现
patch
xen相关补丁目录
linux-2.6-xen-sparse
xen内核目录树结构，含有脚本mkbuildtree构建内核目录树
pristine-linux-2.6.16
由linux-2.1.16.tar.bz2解压得到的内核源代码
ref-linux-2.6.16
拷贝pristine-linux-2.6.16目录中的代码，使用patch目录中的补丁对pristine-linux-2.6.16打补丁得到ref-linux-2.6.16中的源码。
Xen内核编译的过程总结如下：首先从kernel.org网站上下载linux内核linux-2.6.16.tar.bz2，然后将源码解压pristine-linux-2.6.16目录下，拷贝得到ref-linux-2.6.16目录，然后使用patch目录中的补丁对ref-linux-2.6.16目录中的源码打补丁，再拷贝ref-linux-2.6.16目录得到linux-2.6.16-xen，然后使用linux-2.6-xen-sparse目录中的代码，用脚本mkbuildtree构建内核目录得到最终的linux-2.6.16-xen目录。
17:27 |添加评论 |阅读评论 (1) |固定链接 |写入日志 |可信计算
8月10日
如何为TPM生成AIK证书
如何为TPM生成AIK证书
利用TSS可以编程轻易的产生AIK密钥对，TPM在进行平台身份证明，远程证明时必须用到AIK公钥证书，直
接利用TSS的AIK请求函数Tspi_TPM_CollateIdentityRequest，Privacy CA再解析AIK请求，为它颁发AIK
证书太过麻烦。
我用openssl结合TSS，实现了一个简单产生AIK证书的方法：
1.Tspi_Context_LoadKeyByUUID加载AIK密钥，用Tspi_GetAttribData获取公钥Blob
2.对公钥Blob进行DER编码，注意获得的公钥Blob只是Modulus，加上Exponent，编码得到
subjectPublicKey，最终将公钥DER编码得到SubjectPublicKeyInfo。
3.将SubjectPublicKeyInfo转换为openssl中的EVP_PKEY对象，openssl编程实现加载CA私钥EVP_PKEY对象
,创建证书对象X509，设置证书各项，用CA私钥签名得到证书。
测试生成的AIK证书：
用TSS实现AIK私钥的签名，在验证方使用AIK证书进行验证，验证完全通过。
10:26 |添加评论 |阅读评论 (1) |固定链接 |写入日志 |可信计算
6月28日
VT的发展和展望
VT的发展和展望
qinyu
2005-12-15
虚拟技术可以让计算机使用同样一块芯片在系统中运行多种操作系统或者应用程序。虚拟技术作为一项重要的底层硬件设计技术，主要是CPU芯片对虚拟技术的支持，是Intel公司率先推动和发展的关键技术之一，虚拟技术设计首先出现在英特尔的Xeon处理器中，逐渐的虚拟技术扩展到台式机处理器。
虚拟技术对于整个计算机平台架构有着重要的影响，不管是平台硬件（包括I/O设备），操作系统，系统级软件，应用软件，甚至系统管理等方方面面都随之而发展。我这里将从3方面来讨论VT（Virtualization Technology）未来发展趋势。
1. VT的分类及其功能
现有的主流的OS级结构都是单操作系统，即在同一时间段上，一个硬件架构上只能运行单个操作系统，而单操作系统会有以下缺陷：1）所有用户全部属于某个操作系统，那么这个操作系统上所有的资源都有一组用户共同管理。2）很难获得系统级的强隔离支持。
而VT带来了多OS的支持，从CPU，到其他硬件同时支持运行多个OS，各个OS之间又相互隔离。VT技术按照虚拟程度分为：Full virtualization和Para-virtualization。像VMware，Virtual PC属于Full virtualization，多个Guest OS运行于一个Host OS之上。而Xen等则是多个Guest OS运行于同一硬件架构之上，它们属于Para-virtualization。我这里主要讨论Para-virtualization技术，以Xen为例。
VT技术，特别是Xen，在原有计算机架构上，提供了众多的安全增强功能：强制访问控制，TPM的支持，资源管理，可信路径等。这里我讨论一下资源管理，原来的单OS，所有的资源全部位于同一个OS的资源容器中，而多个OS，资源被虚拟到若干个OS资源容器中，实现了操作系统级的物理资源的复用。硬件级别的VT虚拟技术可以对系统进行硬件分区化操作，实现一个硬件系统对应多个软件系统。这样的虚拟无疑增加了系统的安全性能，管理员和用户分别对应管理区和使用区，普通用户的使用不会对系统带来太大的破坏，出现了问题，管理员也可以很快地解决。
2. VT的当前发展
在产业界，基于VT的产品已经使用，学术界，这方面的研究也随着虚拟机技术研究的深入，不断地向前发展。
2005年，Intel在各个平台上（服务器平台，台式PC平台，移动平台），都将引入双内核技术或64位技术， I/O加速技术、虚拟技术等，这些技术都是Intel公司实施新的平台战略的中流砥柱。2005年11月15日，Intel提供的两款支持VT技术的芯片，分别为672和662。据悉，除了单内核的奔腾4处理器，英特尔还在将于2006年第一季度推出的双内核的奔腾D处理器中添加虚拟技术。到2006年上半年，英特尔将在其余的产品线上使用虚拟技术。
微软今年发布了Virtual Server 2005 R2的产品, Virtual Server提供了增强的隔离功能，一台虚拟计算机的崩溃不会影响到在系统上运行的其它虚拟计算机。
学术界对于VT的研究有Stanford University的Terra虚拟机体系结构和Cambridge University的计算机实验室与Intel研究中心合作的Xen项目，Xen起源于分布式计算项目XenoServer，现在已经完成Xen v2.0的实验系统，XenSource公司在进行商用化，最新系统Xen v3.0，支持Linux，BSD，Debian等OS，Windows XP的虚拟化工作正在进行中。
3. VT的潜在影响
VT技术让一台PC同时支持不同的操作系统以及应用程式，而VT未来将全面导入Intel的中高阶处理器产品，成为标准规格。原有的Intel CPU + Microsoft Windows构建台式PC的市场结构将发生改变。未来对于OS的选择，就像现在选择应用程序软件一样，由多个可替代的OS同时运行。
随着VT的不断发展和成熟，将在多个方面有着广阔的应用前景：1）对OS内核的开发和调试可以在同一硬件结构下进行，调试修改的内核可以在“沙盒”保护的虚拟机中进行，不用选择另一个测试计算机。2）同时运行多个OS，例如进行OS兼容性和性能质量评测。3）将多个服务器应用移到同一硬件上，通过虚拟机边界进行性能和错误隔离。4）应用于集群计算和负载平台。5）便于开发新的OS系统，便于用户自定义OS。
9:54 |添加评论 |固定链接 |写入日志 |可信计算
6月22日
可信计算规范概述
可信计算组织（Ttrusted Computing Group,TCG）是一个非盈利的工业标准组织，它的宗旨是加强在相异计算机平台上的计算环境的安全性。TCG于2003年春成立，并采纳了由可信计算平台联盟（the Trusted Computing Platform Alliance,TCPA）所开发的规范。现在的规范都不是最终稿，都还在不断的更新中，比如：TPM的规范就从原来的v1.0更新到v1.2，现在还在不断的修订。
TCG的规范包括了从硬件TPM芯片，到软件TSS，从安全PC Client，服务器，到可信网络连接TNC，从总体的体系结构，到具体的操作接口，整个TCG规范成为一个统一的整体。
1.      TCG规范体系结构
TCG规范的整体架构参照下图：
目前TCG主要的已经制定的规范有以下几个方面：
1.         TCG体系结构总体规范（Architecture Overview）
2.         基础框架规范(Infrastructure Specifications)
3.         可信平台模块规范(Trusted Platform Module Specifications)
4.         TPM软件栈规范(TSS Specifications)
5.         可信网络连接规范（Trusted Network Connect Specifications）
6.         个人计算机客户端规范（PC Client Specifications）
7.         服务器规范(Server Specific Specifications)
最近还在制定TCG的移动平台的规范，TCG的可信存储规范等都正在制定中。
2.      可信计算的主要规范
1.         TCG体系结构总体规范（Architecture Overview）
Architecture Overview规范中定义了TPM平台的使用场景，TCG规范的总体体系结构，任何人查阅TCG规范，就意味着必须首先了解Architecture规范。
2.         基础框架规范(Infrastructure Specifications)
Infrastructure Specifications主旨在于提高TCG相关技术的互操作性，侧重于可信系统的开发、配置、互操作性方面。
包含子规范有：
¨         TCG Infrastructure Working Group Reference Architecture for Interoperability (Part I) Specification
¨         TCG Infrastructure Working Group Reference Architecture for Integrity Management（Part II）Specification
该规范比较笼统，对于TCG各种子规范的管理有很大帮助，阅读此规范对TCG各个子规范之间互操作方法很有帮助。
3.         可信平台模块规范(Trusted Platform Module Specifications)
TPM Specification详细的阐述了TPM的体系结构，各个部件的功能，设计规范，TPM内部所通讯的数据结构，TPM底层执行的命令规范。
包含子规范有：
¨         TPM Main Part 1 Design Principles Specification
¨         TPM Main Part 2 TPM Structures Specification
¨         TPM Main Part 3 Commands Specification
该规范比较详尽的对TPM的各个方面作了规定，而且比较全面，现在已经生产的TPM芯片全部是遵循该规范，TPM规范应该是相对比较成熟的规范，而且目前已经成为行业标准。此规范定义了TPM相关的底层操作，特别是命令级，电路级实现必须完全参照此规范。
4.         TPM软件栈规范(TSS Specifications)
TSS Specification设计了支持TPM的软件服务层的结构，定义了各层之间的接口，规范了各个角色对于TSS的操作权限。
该方面的规范有：
TCG Software Stack (TSS) Specification Version 1.2
该规范定义了TCG软件开发接口，中间的服务接口。TSS直接和应用挂钩，提供应用程序开发接口，如果要开发可信平台下的安全应用，必须通读TSS规范。
5.         可信网络连接规范（Trusted Network Connect Specifications）
TNC规范设计了网络连接的抽象模型，定义了安全通讯的层次，规定TNC服务器，TNC客户端所必须遵循的操作接口。
主要子规范包含：
¨         TCG Trusted Network Connect,TNC Architecture
¨         TCG Trusted Network Connect,TNC IF-IMC,Specification
¨         TCG Trusted Network Connect,TNC IF-IMV,Specification
该方面标准还在不断修订中，不过TNC支持各种不同的网络结构，兼容Cisco的NAC和Microsoft的NAP，研究可信平台的网络接入，可信网络连接，基于可信连接的安全证明，需要参照这方面的规范。
6.         个人计算机客户端规范（PC Client Specifications）
这方面的规范还不够成熟，各个PC厂商生产的安全PC也是各不相同，TCG定义PC平台的规范只是提供底层的统一接口，具体细节还得看各个厂商如何实现。
7.         服务器规范(Server Specific Specifications)
这方面的规范我们涉及不多，不过支持TPM的服务器在技术上、设计上都是问题比较多的。该规范可以作为可信平台安全技术的应用实现阅读。
10:32 |添加评论 |固定链接 |写入日志 |可信计算
engine和tpm engine研究
engine和tpm engine研究
近日来，研究openssl engine，成功的实现了CSP engine，通过openssl调用CSP engine操作微软提供的密钥库。从sourceforge上下载了TPM的openssl engine，试图将它移植到Windows环境，engine实现接口采用的NTRU的TSS，将tpm engine的开源代码中dso动态加载tss函数改为了通过调用TSPI.dll动态加载tss函数，现在已经完成通过编译，抽空写个测试程序进行测试。
通过这些学习，对openssl engine机制有了深入的了解，现在比较困惑的是engine的控制函数（如init,finish,destroy,control等)如何辅助实现engine的管理。
10:30 |添加评论 |固定链接 |写入日志 |可信计算
4月13日
Lenovo M400S vs IBM M52 8114
配置比较
Lenovo 安全PC配置：
型号：联想开天M400S
芯片组：Intel 915G
CPU：2.93GHz Intel Pentium 4 515
Memory：DDR 256MB
TPM：联想“恒智”，符合TCG 1.2
TPM安全软件：联想安全方案
安全系统：联想LEOS系统
IBM M52 8114配置
型号：IBM M52 8114
芯片组：Intel 945G Express
CPU：Intel Pentium 4 531 3 GHz - 64-Bit，Hyper-Threading Technology,
Memory：DDR2 512M
TPM：National Semiconductor TPM，符合TCG 1.2
TPM安全软件：Client Security Solution
安全系统：Client Security Solution，Rescue Recovery
ThinkCentre的特点
ThinkCentre 在每个用户初始化时，创建个人用户密钥，该密钥受TPM保护。
提供有口令管理，虚拟磁盘管理，用户数据迁移，安全备份与恢复等功能。
提供的工具有：
Client Security Solution（主要工具）：口令管理和虚拟磁盘管理
Rescue and Recovery：安全备份与恢复
System Migration Assistant：用户数据迁移
个人点评：
TPM的用途限于用户层次，每个用户创建一个个人密钥，该密钥用于保护开机口令。无TPM管理工具，无密钥管理，数据保护通过虚拟磁盘的保护实现。ThinkCentre原有的安全功能很强大，使用时让人感觉不到TPM的存在，这些都做得很人性化。但是TPM的强大的存储保护功能，密钥保护功能都没有实现。
M400S的特点
Lenovo的安全PC建立了从硬件到OS的信任链，和单独的应用程序信任管理，试图实现整个系统的信任链。同样提供口令管理，虚拟磁盘管理，备份与恢复。
个人点评：
TPM的用途不限于用户层次，而是突破用户层次，直接到应用程序那一层次，TPM如果能够实现对应用程序的密钥管理，将很占优势。但Lenovo目前的功能还有很大缺陷，比如TPM管理工具产生的密钥，尽然没有应用到加密，签名等方面。
功能比较
1.信任链：
ThinkCentre：无明显的启动信任链（至少未显式实现），进入OS才开始检测芯片。
Lenovo：明显的系统启动检测，但信任链从OS开始截断，应用程序的信任由用户制订信任策略控制，通过系统智能防护工具实现。
比较：Lenovo占优势
2.系统恢复：
ThinkCentre：提供系统文件的备份，恢复，备份恢复的范围为整个系统。在Windows运行环境下提供单个文件的恢复。
Lenovo：提供系统重要文件的检测，备份，恢复，范围为系统文件。Windows运行环境下不提供任何恢复功能。
比较：ThinkCentre提供的功能更强
3.文件迁移：
ThinkCentre：提供个人数据文件（如Favourite，Desktop等）的迁移。
Lenovo：无
比较：ThinkCentre更优
4.口令保护：
ThinkCentre：提供口令保护功能，使用鼠标拖动，获取口令窗口焦点。
Lenovo：提供口令保护，类似于ThinkCentre。
比较：功能差不多，平手
5.密钥管理：
ThinkCentre：无
Lenovo：TPM工具提供创建以SRK为根的用户层次密钥。
比较：Lenovo占优势
6.启动认证：
ThinkCentre：使用安全芯片认证用户，即用户口令受芯片保护。还留有指纹认证扩展。
Lenovo：直接使用Windows密码认证。
比较：ThinkCentre占优势
7.TSS实现：
ThinkCentre：TSS动态链接库实现了TCG TSSv1.1的接口
Lenovo：TSS动态链接库没有实现TSS的导出接口
比较：ThinkCentre更好
8.TPM的控制：
ThinkCentre：BIOS控制开启，Windows OS检查芯片
Lenovo：BIOS控制，按钮控制，OS不检查芯片，应用时检查。
比较：Lenovo更人性化
9.TPM管理工具
ThinkCentre：无
Lenovo：有简单的管理工具，但是创建的密钥无法使用。
比较：Lenovo更适合于专业用户，功能更好
10.进程信任管理
ThinkCentre：无
Lenovo：提供应用程序信任管理，失败。
比较：Lenovo虽然实现了这一功能，但是一大败笔。
11.虚拟磁盘管理：
ThinkCentre：为个人用户提供创建虚拟磁盘，受个人用户密钥保护。
Lenovo：为个人用户提供创建虚拟磁盘，创建虚拟磁盘的同时创建受保护密钥。
比较：ThinkCentre的功能更强大
ThinkCentre和Lenovo的M400S对比列表：
符号说明：√表示功能更强，---表示无此项功能，==功能稍弱
IBM ThinkCentre
Lenovo M400S
1、信任链
---
√
2、系统恢复
√
==
3、文件迁移
√
---
4、口令保护
√
√
5、密钥管理
---
√
6、启动认证
√
==
7、TSS实现
√
==
8、TPM的控制
==
√
9、TPM管理工具
---
√
10、进程信任管理
---
×
11、虚拟磁盘管理
√
==
总计
6
5
总结：谁控制了应用，谁就是胜利者。可信平台能够支持更为广泛的应用，例如：提供良好的应用程序密钥管理保护，提供易用的TSS对外接口，在TSS的基础上提供SDK集成开发环境（IDE），那么可信平台就能全面支撑起整个应用框架。
10:50 |添加评论 |阅读评论 (2) |固定链接 |写入日志 |可信计算
国内安全PC配置比较
国内市场上已经出现了安全PC，下面的列表对几款常遇到的安全PC配置进行比较。
机型
芯片组
处理器
内存
TPM安全芯片
TPM安全软件
安全系统
方正君逸M500
Intel 945G
双核2.8GHz Intel Pentium D 820
DDR2 512MB
兆日SSX35，符合TCG 1.2
兆日安全方案
方正智能安全系统
惠普Compaq dc7600
Intel 945G
双核2.8GHz Intel Pentium D 820
DDR2 1024MB
Broadcom网卡芯片整合，符合TCG 1.2
惠普安全方案
Altiris Local Recovery
浪潮英政3600
Intel 945G
双核2.8GHz Intel Pentium D 820
DDR2 512MB
兆日SSX35，符合TCG 1.2
兆日安全方案
浪潮PC管理中心（可选）
联想开天M400S
Intel 915G
2.93GHz Intel Pentium 4 515
DDR 256MB
联想“恒智”，符合TCG 1.2
联想安全方案
联想LEOS系统
清华同方超翔C4200
Intel 915G
64位3.0GHz Intel Pentium 4 630
DDR 512MB
兆日SSX35，符合TCG 1.2
兆日安全方案
同方电脑急救中心（可选）
10:46 |添加评论 |固定链接 |写入日志 |可信计算
4月8日
可信计算的标准汇总
可信计算的标准汇总
可信计算组织（Ttrusted Computing Group,TCG）是一个非盈利的工业标准组织，它的宗旨是加强在相异计算机平台上的计算环境的安全性。TCG于2003年春成立，并采纳了由可信计算平台联盟（the Trusted Computing Platform Alliance,TCPA）所开发的规范。现在的规范都不是最终稿，都还在不断的更新中，比如：TPM的规范就从原来的v1.0更新到v1.2，现在还在不断的修订。
TCG规范体系结构
目前TCG主要的已经制定的规范有以下几个方面：
1.         基础框架规范(Infrastructure Specifications)
2.         可信平台模块规范(Trusted Platform Module Specifications)
3.         TPM软件栈规范(TSS Specifications)
4.         可信网络连接规范（Trusted Network Connect Specifications）
5.         个人计算机客户端规范（PC Client Specifications）
6.         服务器规范(Server Specific Specifications)
最近还在制定TCG的移动平台的规范，计划的是今年完成该规范的草稿。
可信计算的主要标准
1.         基础框架规范(Infrastructure Specifications)
Infrastructure Specifications主旨在于提高TCG相关技术的互操作性，侧重于可信系统的开发、配置、互操作性方面。
包含子规范有：
¨         TCG Infrastructure Working Group Reference Architecture for Interoperability (Part I) Specification
¨         TCG Infrastructure Working Group Reference Architecture for Integrity Management（Part II）Specification
该规范比较笼统，对于TCG的管理有很大帮助，但不适合作为标准，可是作为系统配置参考文献。
2.         可信平台模块规范(Trusted Platform Module Specifications)
TPM Specification详细的阐述了TPM的体系结构，各个部件的功能，设计规范，TPM内部所通讯的数据结构，TPM底层执行的命令规范。
包含子规范有：
¨         TPM Main Part 1 Design Principles Specification
¨         TPM Main Part 2 TPM Structures Specification
¨         TPM Main Part 3 Commands Specification
该规范比较详尽的对TPM的各个方面作了规定，而且比较全面，现在已经生产的TPM芯片全部是遵循该规范，TPM规范应该是相对比较成熟的规范，而且目前已经成为行业标准。该方面的规范在我国应该尽早的定为标准。
3.         TPM软件栈规范(TSS Specifications)
TSS Specification设计了支持TPM的软件服务层的结构，定义了各层之间的接口，规范了各个角色对于TSS的操作权限。
该方面的规范有：
TCG Software Stack (TSS) Specification Version 1.10
该方面的规范比较成熟，原有的规范应该不会有大的修改，最多再原有TSS规范上增加一些新的功能。而且TSS直接和应用挂钩，将TSS定为标准会对规范应用有很大作用。
4.         可信网络连接规范（Trusted Network Connect Specifications）
TNC规范设计了网络连接的抽象模型，定义了安全通讯的层次，规定TNC服务器，TNC客户端所必须遵循的操作接口。
主要子规范包含：
¨         TCG Trusted Network Connect,TNC Architecture
¨         TCG Trusted Network Connect,TNC IF-IMC,Specification
¨         TCG Trusted Network Connect,TNC IF-IMV,Specification
该方面标准今年才制定完毕，还在不断修订中，不过TNC支持各种不同的网络结构，兼容Cisco的NAC，如果能够经受得住网络界应用的考验，比较容易成为标准。
5.         个人计算机客户端规范（PC Client Specifications）
这方面的规范还不够成熟，各个PC厂商生产的安全PC也是各不相同，TCG定义PC平台的规范影响力还不够。
6.         服务器规范(Server Specific Specifications)
这方面的规范我还没有涉及到，不过支持TPM的服务器在技术上、设计上都是问题比较多的。建议不予考虑。
1:37 |添加评论 |固定链接 |写入日志 |可信计算
10月18日
New security proposed for do-it-all phones(zz)
New security proposed for do-it-all phones
By Joris Evers
http://news.com.com/New+security+proposed+for+do-it-all+phones/2100-1037_3-5883341.html
Story last modified Tue Sep 27 04:00:00 PDT 2005
As mobile phones become digital do-it-alls, handsets need better protection from hackers and from unauthorized access when they're lost or stolen, says an industry group proposing new, hardware-based security standards for the devices.
The Trusted Computing Group (TCG)--backed by big names like Nokia, Motorola, Intel, Samsung, VeriSign and Vodafone--plans to unveil its plan Tuesday at a conference sponsored by the Cellular Telecommunications & Internet Association. The TCG has already developed similar specifications for PCs and servers.
In addition to voice calls, cell phones are increasingly used for taking pictures, keeping a calendar and sending text messages and e-mail. In the future they could replace wallets, say industry pundits, with consumers whipping out a specially equipped phone instead of a credit card to pay for a purchase. That would make securing the gadgets even more important.
"Without proper security, mobile phones may become a target for hackers and malicious software," said Janne Uusilehto, senior technology manager at Nokia and chairman of the TCG's Mobile Phone Working Group. "The benefit of hardware-based security is that users can rely on their phone and (know) that private data is protected."
The proposed standard doesn't just protect user data. The security hardware also enables copyright protection, according to the TCG, a feature demanded by the entertainment industry. This so-called digital rights management technology could mean access to more exclusive content on cell phones, but it could also limit the content that will play on devices.
Additionally, says the TCG, cell phone operators could use the technology to get more control over the devices they sell. Operators would get a better way to lock devices to their networks and tighten control over which services and software can run on the gadgets. But user-rights advocates complain that such things limit consumers' choice and freedom.
The TCG's plans call for mobile handset hardware to support features similar to those of the Trusted Platform Module. The TPM is a security chip designed for PCs and servers that enables a variety of security features, including authentication, protected storage and secure e-mail. The TPM technology will need to be adapted because mobile phones are much smaller than PCs.
At the CTIA wireless event, the TCG will introduce its plans by sharing "use cases" for hardware-based security in cell phones. The group plans to release a blueprint designed to make it possible to include security technology in mobile handsets in the first half of 2006, representatives told CNET News.com.
Adding hardware-based security to cell phones can enable services such as electronic ticketing and mobile payments, according to the TCG. It can also provide for secure storage of personal information such as an address book, text messages, e-mail and pictures. And, in the future, payment data such as credit card numbers will be added to the mix, the TCG said.
"Nowadays my Treo 650 has some files from my corporation. It would be nice to have the phone rendered unusable if it gets lost," said Thomas Hardjono, a principal scientist at VeriSign and member of the TCG Mobile Phone Working Group. The Palm Treo 650 is a phone with features such as e-mail, a calendar and a camera.
As handsets get smarter and used for more than just voice calls, the threat of hacker attacks and mobile phone viruses rises, Nokia's Uusilehto said. The new security features can protect the devices against such threats, he said.
"Mobile phones are becoming full of security-demanding services," Uusilehto said. "Attacks are not a major problem today, and that makes the timing pretty good for us. We have time to do security properly, where we are not in a firefighting mode."
In addition to enabling new services and protecting user data, the TCG's proposals can also be used to secure copyright-protected data on mobile phones. That use of the new security features is critical to content services, said VeriSign's Hardjono. VeriSign is a significant player in the mobile content business with its Jamba and Jamster services.
"We want to sell content, but the folks in Hollywood don't want to sign the paperwork because they want guarantees that the devices have got proper security," Hardjono said. "No DRM, no content."
But digital rights management is one way the proposed security technology could restrict cell phone users, say some user-rights advocates. Operators would also get a better way to lock phones to their networks and close control of the services and applications that can run on devices.
"A lot of carriers have a model of trying to tax everything that goes into a phone, which we think is unfortunate," said Seth Schoen, staff technologist at the Electronic Frontier Foundation. "The TPM is just another tool to let them do these things."
Although the Trusted Platform Module is controversial on the PC because consumers expect a lot of freedom when using their computer, the same is not true for mobile phones. "In the cell phone market there is an assumption--rarely questioned--that restricting the end user is the natural thing carriers do," Schoen said. "I don't see the TPM in phones changing the user experience."
Hardware-based security is not new to the mobile phone space, said Nokia's Uusilehto, but manufacturers have so far each gone their own way. The Trusted Computing Group aims to provide a standard, which should reduce costs for handset makers and let component suppliers standardize.
"Today we're wasting a lot of resources and inventing the wheel again here and there, instead of doing it together in this open approach," Uusilehto said.
Nokia, the world's biggest handset maker, plans to use the TCG's security specifications, Uusilehto said. However, he could not say which products would include the technology and when those might become available.
It took several years for PCs with TPM chips to appear. Gartner analyst John Pescatore believes it won't be until about 2008 before cell phones with the new security technology hit stores.
Previous Next "The major problem is not that the technology is so difficult, but that the market is fractured," he said. While the PC market is dominated by Intel and Microsoft, the mobile phone space has many different players who will need more time to coordinate, he said.
Though the industry sees broad use for its security technologies, Pescatore thinks large businesses will be the first to buy devices that have the added security technology. Employees are accessing corporate data on their mobile devices and there is a need for more "trustable" devices, he said.
Consumers initially will not want to pay for the extra features, Pescatore said. "What consumers really want are smaller phones and lighter phones, and they don't want to pay a lot for them. Adding security hardware can make the phone more expensive, thicker and take more battery power."
-------------------------------------------------------------------------------------------
Locking up cell phones
The Trusted Computing Group provides 10 examples of what its plan for hardware-based security could enable in mobile phones.
1. Platform integrity to ensure the hardware and software are in a state intended by the manufacturer.
2. Device authentication to protect and store identities of users and bind the device to the appropriate user.
3. Digital rights management to protect content on the phone.
4. SIMlock/device personalization to ensure a device is locked to its network and can't be easily stolen.
5. Secure software download to enable the safe download of updates, patches and other software.
6. Secure channel between different parts of the phone to prevent tampering by malicious software.
7. Mobile ticketing to enable the secure download of tickets and manage them.
8. Mobile payment to enable the secure execution of payments.
9. Software use to ensure software is safe, and if not, that it can be removed, replaced or not executed.
10. User data protection to allow users to prevent their information from being accessed or viewed by unauthorized people and to give users access to services or data that might not require personal information.
Source: Trusted Computing Group.
20:13 |添加评论 |固定链接 |查看引用通告 (1) |写入日志 |可信计算
10月14日
Introduction of TCP progress
Introduction of TCP progress
qinyu--2005.10.14
In present infrastructure there are concrete methods to deal with special security problems, such as firewall, IDS (Intrusion Detected System), anti-virus. It is not efficient, thorough for distributed computing security problem. Whether the host system is trusted to remote party, is most important in distributed environment. Why trust is most important, what is the relation to security? Trust is that the system with the context of whole environment executes as the expected behavior on subjective judgments of users, while security is system property in objective factor. They are two aspects like two sides of a coin. If the system is security, it is trusted for users. If it is trust, the system is also security. The major goal of Trusted Computing Platform (TCP) is implementing the trustworthiness of two remote parties in distributed computing.
Trust system is neither new nor invented by TCG (Trusted Computing Group).Actually trust system can date back to the 1960s and was driven by government and military need for effective information protection. Trusted Computing System Evaluation Criteria (TCSEC)  in early 1980s also known as Orange Book, first forms the standard definition of a trust computer system, how to evaluate and ensure them. But all of these are for single computer system with terminal access. Establish trust for two remote parties relies on Trust Third Party (TTP), for example Alice request Bob's service providing the certificate signed by trusted CA. Assurance of identity can be provided by TTP, but real time system configure can not be obtained by TTP, TTP can not reveal the real time security configure to remote party. If the system is able to measure its own integrity and report to remote party, trust can be established between the two parties. Based on this idea, the design and application of TCP appears. The research of TCP is originated from secure boot which implies that a system can measure its own integrity and terminate boot process if an integrity failure is detected. The AEGIS system implemented by Arbaugh  et al. is the first research on secure boot. The AEGIS system describes a secure bootstrap process for IBM PC system also allowing recovery from failure integrity. Hashes of loaded modules measured by secure bootstrap are compared with stored signatures before being executed; each layer validates the integrity of subsequent layer, started from a trusted portion of BIOS.
The early research on TCP is began with the secure coprocessor, started from Logical Coprocessing Kernel (LOCK)  of US defense in 1973. This project attempt to use hardware with other tools, based on theory of virtual machine monitor, to build a “highly trustworthy” sub community system. This project is particularly influential on early research and development of TCP. Secure coprocessor is generally defined as a computing environment, collocated at host machine, which can safely protect security-sensitive computing with some assurance. The early researches like Kent, Abyss, Citadel, Dyad  are foundation of the TCP research. Depending on these early researches, IBM 4758 secure coprocessor  is designed and built. It is a high end device, providing a robust, general purpose computational environment.
With TCP technique of IT industry proceeding, such as LaGrande  technique of Intel, NGSCB (Next Generation Secure Computing Base)  of Microsoft, the product and application of TCP is gradually mature. A serial of TCP specifications are issued by TCG (Trusted Computing Group) founded in 2003. TCG is advanced from TCPA (Trusted Computing Platform Alliance) sponsored by IBM, HP, Microsoft, Intel et al, and It is a non-profit standard organization with the aim of enhancing computing environment security by TPM (Trusted Platform Module). TPM is defined as a hardware instantiation kept to TCG specification, and is an embedded chip on the motherboard in computing platform. TCG provides a root trust with TPM, which can uniquely identify a particular platform, and provides various crypto capabilities including asymmetric and symmetric algorithm, hashing and MAC (Message Authentication Code) algorithm. TCP devices include secure coprocessor, cryptographic accelerator, TPM, personal token et al  , and TPM is a most practical one of all.
TCP measure the system integrity and convinces the remote party that the requested system is running in safe status now. TCP assure system integrity, identity authentication, information privacy. Circled around TCP for example TPM, a huge security infrastructure is shaping a new scope, various devices such as Servers, PDA, notebooks, desktops, input devices, storage devices, mobile phones, all of those are kept to TCG specification. TCP research is in a expansive space, enhancing system security, remote attestation, grid security, mobile phone communication security, access control in distributed computing, and all are in new research direction surrounding TCP.
18:11 |添加评论 |固定链接 |写入日志 |可信计算
10月12日
TCP研究机构汇总
TCP研究机构汇总
秦 宇--2005.9.14
IBM Waston Research
主要研究系统的完整性测量和完整性报告，实现C/S的远程认证。
相关文献Design and Implementation of a TCG-based Integrity Measurement ArchitectureThe Role of TPM in Enterprise SecurityBuilding the IBM 4758 Secure Coprocessor
Dartmouth University
Department of Computer Science, Dartmouth University
研究了Linux下的安全增强模块，开发了两个系统工具enforcer和security admin，在enforcer的基础上实现Web Server的SSL安全增强应用，安全增强的OpenCA系统等。
相关文献
An Open-Source Virtual Secure Coprocessor based on TCPAOpen-Source Applications of TCPA HardwareWebALPS Implementation and Performance Analysis-Using Trusted Co-servers to Enhance Privacy and Security of Web InteractionsWebALPS： A Survey of E-Commerce Privacy and Security Applications
Stanford University
Computer Science Department,Stanford University
基于VM技术，设计Terra体系结构，基于TVMM（trusted virtual machine monitor）建立了一个新型的OS体系结构，并在Terra Architecture上作了相关的实验研究。
相关文献
Terra：A Virtual Machine-Based Platform for Trusted ComputingFlexible OS Support and Applications for Trusted Computing
Cambridge University
University of Cambridge Computer Laboratory
与Intel合作开发TPM的虚拟技术，实现Xen virtual machine monitor。
相关文献
Xen and the Art of Virtualization
HP Lab
Hewlett-Packard Research Labs
HP启动了一系列关于TC应用的研究项目，主要领域包括：网格安全、可信生物认证、可信移动平台等
相关文献
A Trusted Biometric SystemOn Enhancing Biometric Authentication with Data protectionHow Trusted Computers can Enhance for Privacy Preserving Mobile ApplicationsInnovations for Grid Security from Trusted Computing
George Mason University
研究分布式环境下，可信平台的P2P访问控制
相关文献
Peer to Peer Access Control Architecture Using Trusted Computing Technology
13:28 |添加评论 |固定链接 |写入日志 |可信计算
TCP（Trusted Computing Platform）研究进展汇总
TCP（Trusted Computing Platform）研究进展汇总
秦 宇--2005.9.14
本索引只列举各个领域内可信计算研究的文献情况，详细内容请参照《TCP科研进展汇总》
系统安全
可信计算平台的操作系统构架，虚拟技术，安全协处理器，系统安全增强，完整性度量和报告等
参考文献
远程证明
可信计算模块TPM向远端证明自己可信
参考文献
数字版权
DRM（Digital Right Management），包含DRM的体系结构和实现机制，TCP与DRM的关系等等
参考文献
移动通讯
TCP在移动平台的应用，TCP保护移动平台的隐私性等等
参考文献
网格计算
TCP增强网格计算的安全性，基于TCP的新一代网格体系结构等
参考文献
访问控制
TCP平台下如何增强访问控制功能，P2P环境如何实现远端的访问控制
参考文献
Web服务器
基于TCP的Web服务器安全增强方案
参考文献
PKI系统
如何使用TCP增强PKI系统的安全
参考文献
电子商务
基于TCP设计更为安全的电子商务协议
参考文献
http://international.visa.com/fb/paytech/secure/main.jsp
生物认证
研究可信计算生物认证系统
参考文献
其他
参考文献
开源代码
汇总可信计算平台开源代码的情况
TPM Device Driver
Linux Device Driver/library/applications
http://www.research.ibm.com/gsal/tcpa
说明：IBM提供的TPM在linux系统下的Device Driver
Official Device Driver included in 2.6.12 kernel
http://sourceforge.net/projects/tpmdd
说明：IBM提供的linux内核2.6.12下的TPM驱动
NetBSD下的TPM Driver
http://www.citi.umich.edu/u/rwash/projects/trusted/netbsd.html
说明：密歇根大学的Rick Wash提供的NetBSD下的TPM Driver
TCG Software Stack（TSS）
IBM TrouSerS
http://sourceforge.net/projects/trousers
说明：IBM提供的Linux下的TSS，其中包含两个应用程序，一个控制TPM状态，一个PKCS#11的数据存储。
其他
Dartmouth enforcer--Linux Security Module
http://sourceforge.net/projects/enforcer
说明：Dartmouth提供的OS的安全增强部件，用于实现文件系统的防窜改。
Swiss Federal Institute of Technology – TPM emulator
http://www.infsec.ethz.ch/people/psevinc/
Software-based TPM Emulator
https://developer.berlios.de/projects/tpm-emulator
13:12 |添加评论 |阅读评论 (2) |固定链接 |写入日志 |可信计算
9月29日
Carnivore's New Leash on Life? (zz)
Carnivore's New Leash on Life? (zz)
By Declan McCullagh
04/19/2002
SAN FRANCISCO -- A graduate student at Dartmouth College wants to tame the FBI's Carnivore surveillance system. Alex Iliev has proposed a way to force anyone who wants to monitor e-mail or Web browsing to follow the rules -- and not snoop on private data that should be off-limits.
Iliev's system relies on technology, not Congress or federal judges, to keep Carnivore on a very short leash.
Much of the public outcry over Carnivore and similar eavesdropping methods arises because they take a vacuum-cleaner approach, sucking in all the data flowing through a network and then storing only the desired information. But if the snooperware is buggy or if police agencies go beyond what a court order allows, the system will snare far more traffic than it is authorized to retain.
Iliev's proposal, titled "Prototyping an Armored Data Vault" (PDF) and presented at the Privacy Enhancing Technologies workshop this week, says "a design goal is to store packets securely, so that they may be accessed only through the security mechanism imposed by the vault."
Here's how it works: An Internet service provider, university or corporation could choose to record all activities of people using the network. The data would be encrypted, with the only key able to unlock the information kept by the vault.
An FBI agent who wanted to access the information would obtain a search order that was digitally signed by a judge. The vault would recognize that signature and divulge only the information specified by the court. There would be no chance -- assuming the vault was programmed properly -- for a fishing expedition.
Even if the FBI physically seized the vault, legally or otherwise, it's supposed to be just about impossible for the cops to crack. Iliev's program runs on an IBM 4758 cryptographic coprocessor, designed to destroy itself if it detects an intrusion attempt.
IBM says its coprocessor features "physical penetration, power sequencing, temperature, and radiation sensors to detect physical attacks against the encapsulated subsystem." The U.S. government has certified it to meet the FIPS 140-1 standard at level 4, the most secure.
The U.S. Department of Justice and IBM partially funded this research. Since the Sept. 11 terrorist attacks, FBI use of Carnivore has increased sharply.
Iliev says he isn't necessarily suggesting that administrators store terabytes of traffic -- after all, the best way to protect someone's privacy is never to have their information on file in the first place.
Rather, Iliev says, if an administrator is required to play Big Brother, he wants them to have a reasonable way to do it.
"It might be preferable if collection of data to a large extent were not deemed necessary," says Iliev, who is a 23-year-old PhD candidate in Dartmouth's computer science department. "But if it is, then people might be more willing to bear with this. People can be confident how it would proceed."
"We want this to take place in an environment where people who have their data collected can be confident that how they agreed to have their data accessed will be how it will be accessed," he says.
Other applications for the vault, beyond storing network data, include encrypting medical or financial information that would be released only to authorized users.
Sean Smith, an assistant professor of computer science who co-authored the paper with Iliev, previously worked at IBM where he designed the software for the coprocessor.
"We tried to make it as unbreakable as feasible," Smith says. "As far as we know, it's held up."
The source code for the vault, which runs under the Linux operating system, is available on Dartmouth's website:http://www.cs.dartmouth.edu/~pkilab/code/vault.tar.gz
11:53 |添加评论 |固定链接 |写入日志 |可信计算