@super-protocol/sp-nvtrust-wrapper 1.0.0

package/py/nvtrust_wrapper.py

@@ -0,0 +1,100 @@
+import sys
+import os
+import proto.nvtrust_wrapper_types_pb2 as proto
+from nv_attestation_sdk import attestation
+from nvml_helper import NvmlHelper
+
+def get_nvidia_topology():
+    nvmlHelper = NvmlHelper()
+
+    result = proto.GPUTopologyResult()
+    result.gpuCount = nvmlHelper.get_number_of_gpus()
+    result.nvswitchCount = nvmlHelper.get_number_of_switches()
+    
+    return result
+
+def create_attestation_client(deviceType: proto.NvidiaDeviceType):
+    client = attestation.Attestation()
+    client.set_name("superprotocol-node")
+
+    url = ""
+    device = None
+    if deviceType == proto.NvidiaDeviceType.GPU:
+        device = attestation.Devices.GPU
+        url = "https://nras.attestation.nvidia.com/v3/attest/gpu"
+    elif deviceType == proto.NvidiaDeviceType.SWITCH:
+        device = attestation.Devices.SWITCH
+        url = "https://nras.attestation.nvidia.com/v3/attest/switch"
+    else:
+        raise Exception("Unsupported device type: {}".format(device))
+
+    client.add_verifier(device, attestation.Environment.REMOTE, url, "")
+    return client
+
+def get_nras_token(params: proto.GetNRASToken):
+    client = create_attestation_client(params.device)
+    client.set_nonce(params.nonce)
+
+    evidence_list=[
+    {
+        "certificate": "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",
+        "evidence": "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"
+    }]
+    evidence_list = client.get_evidence({ 'ppcie_mode': params.ppcieMode })
+
+    attest = client.attest(evidence_list)
+    if attest == False:
+         raise Exception("Attest return false")
+    
+    result = proto.NvidiaToken()
+    
+    result.jwt = client.get_token()
+    return result
+
+def nras_validate_token(params: proto.ValidateToken):
+    client = create_attestation_client(params.device)
+    attestation_result = client.validate_token(params.policy, params.token.jwt)
+    if attestation_result == False:
+        raise Exception("Token verification failed")
+
+    result = proto.VerificationResult()
+    result.success = True
+    return result
+
+def handle_request(serialized_data):
+    request = proto.MethodCallRequest()
+    request.ParseFromString(serialized_data)
+    
+    result = None
+    if request.HasField("topology"):
+        result = get_nvidia_topology()
+    elif request.HasField("nrasToken"):
+        result = get_nras_token(request.nrasToken)
+    elif request.HasField("validateToken"):
+        result = nras_validate_token(request.validateToken)
+
+    else:
+        raise Exception("Unknown method in request")
+    
+    return result.SerializeToString()
+
+if __name__ == "__main__":
+    print("main")
+    _, tmpDir = sys.argv
+    
+    exitcode = 0
+    try:
+        with open(os.path.join(tmpDir, "request.bin"), "rb") as f:
+            serialized_data = f.read()  
+        serialized_response = handle_request(serialized_data)
+        
+        with open(os.path.join(tmpDir, "response.bin"), "wb") as f:
+            f.write(serialized_response)
+    except Exception as e:
+        print(e)
+        with open(os.path.join(tmpDir, "error.txt"), "w") as f:
+            f.write(str(e))
+        exitcode = 1
+    exit(exitcode)
+
+

package/py/proto/nvtrust_wrapper_types_pb2.py

@@ -0,0 +1,39 @@
+# -*- coding: utf-8 -*-
+# Generated by the protocol buffer compiler.  DO NOT EDIT!
+# source: nvtrust_wrapper_types.proto
+"""Generated protocol buffer code."""
+from google.protobuf.internal import builder as _builder
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import descriptor_pool as _descriptor_pool
+from google.protobuf import symbol_database as _symbol_database
+# @@protoc_insertion_point(imports)
+
+_sym_db = _symbol_database.Default()
+
+
+
+
+DESCRIPTOR = _descriptor_pool.Default().AddSerializedFile(b'\n\x1bnvtrust_wrapper_types.proto\x12\x15nvtrust_wrapper_types\"\x10\n\x0eGetGPUTopology\"<\n\x11GPUTopologyResult\x12\x10\n\x08gpuCount\x18\x01 \x01(\r\x12\x15\n\rnvswitchCount\x18\x02 \x01(\r\"i\n\x0cGetNRASToken\x12\x37\n\x06\x64\x65vice\x18\x01 \x01(\x0e\x32\'.nvtrust_wrapper_types.NvidiaDeviceType\x12\r\n\x05nonce\x18\x02 \x01(\t\x12\x11\n\tppcieMode\x18\x03 \x01(\x08\"\x1a\n\x0bNvidiaToken\x12\x0b\n\x03jwt\x18\x01 \x01(\t\"\x8b\x01\n\rValidateToken\x12\x31\n\x05token\x18\x01 \x01(\x0b\x32\".nvtrust_wrapper_types.NvidiaToken\x12\x0e\n\x06policy\x18\x02 \x01(\t\x12\x37\n\x06\x64\x65vice\x18\x03 \x01(\x0e\x32\'.nvtrust_wrapper_types.NvidiaDeviceType\"%\n\x12VerificationResult\x12\x0f\n\x07success\x18\x01 \x01(\x08\"\xd1\x01\n\x11MethodCallRequest\x12\x39\n\x08topology\x18\x01 \x01(\x0b\x32%.nvtrust_wrapper_types.GetGPUTopologyH\x00\x12\x38\n\tnrasToken\x18\x02 \x01(\x0b\x32#.nvtrust_wrapper_types.GetNRASTokenH\x00\x12=\n\rvalidateToken\x18\x03 \x01(\x0b\x32$.nvtrust_wrapper_types.ValidateTokenH\x00\x42\x08\n\x06method*\'\n\x10NvidiaDeviceType\x12\x07\n\x03GPU\x10\x00\x12\n\n\x06SWITCH\x10\x01\x62\x06proto3')
+
+_builder.BuildMessageAndEnumDescriptors(DESCRIPTOR, globals())
+_builder.BuildTopDescriptorsAndMessages(DESCRIPTOR, 'nvtrust_wrapper_types_pb2', globals())
+if _descriptor._USE_C_DESCRIPTORS == False:
+
+  DESCRIPTOR._options = None
+  _NVIDIADEVICETYPE._serialized_start=662
+  _NVIDIADEVICETYPE._serialized_end=701
+  _GETGPUTOPOLOGY._serialized_start=54
+  _GETGPUTOPOLOGY._serialized_end=70
+  _GPUTOPOLOGYRESULT._serialized_start=72
+  _GPUTOPOLOGYRESULT._serialized_end=132
+  _GETNRASTOKEN._serialized_start=134
+  _GETNRASTOKEN._serialized_end=239
+  _NVIDIATOKEN._serialized_start=241
+  _NVIDIATOKEN._serialized_end=267
+  _VALIDATETOKEN._serialized_start=270
+  _VALIDATETOKEN._serialized_end=409
+  _VERIFICATIONRESULT._serialized_start=411
+  _VERIFICATIONRESULT._serialized_end=448
+  _METHODCALLREQUEST._serialized_start=451
+  _METHODCALLREQUEST._serialized_end=660
+# @@protoc_insertion_point(module_scope)

package/py/proto/nvtrust_wrapper_types_pb2.pyi

@@ -0,0 +1,65 @@
+from google.protobuf.internal import enum_type_wrapper as _enum_type_wrapper
+from google.protobuf import descriptor as _descriptor
+from google.protobuf import message as _message
+from typing import ClassVar as _ClassVar, Mapping as _Mapping, Optional as _Optional, Union as _Union
+
+DESCRIPTOR: _descriptor.FileDescriptor
+GPU: NvidiaDeviceType
+SWITCH: NvidiaDeviceType
+
+class GPUTopologyResult(_message.Message):
+    __slots__ = ["gpuCount", "nvswitchCount"]
+    GPUCOUNT_FIELD_NUMBER: _ClassVar[int]
+    NVSWITCHCOUNT_FIELD_NUMBER: _ClassVar[int]
+    gpuCount: int
+    nvswitchCount: int
+    def __init__(self, gpuCount: _Optional[int] = ..., nvswitchCount: _Optional[int] = ...) -> None: ...
+
+class GetGPUTopology(_message.Message):
+    __slots__ = []
+    def __init__(self) -> None: ...
+
+class GetNRASToken(_message.Message):
+    __slots__ = ["device", "nonce", "ppcieMode"]
+    DEVICE_FIELD_NUMBER: _ClassVar[int]
+    NONCE_FIELD_NUMBER: _ClassVar[int]
+    PPCIEMODE_FIELD_NUMBER: _ClassVar[int]
+    device: NvidiaDeviceType
+    nonce: str
+    ppcieMode: bool
+    def __init__(self, device: _Optional[_Union[NvidiaDeviceType, str]] = ..., nonce: _Optional[str] = ..., ppcieMode: bool = ...) -> None: ...
+
+class MethodCallRequest(_message.Message):
+    __slots__ = ["nrasToken", "topology", "validateToken"]
+    NRASTOKEN_FIELD_NUMBER: _ClassVar[int]
+    TOPOLOGY_FIELD_NUMBER: _ClassVar[int]
+    VALIDATETOKEN_FIELD_NUMBER: _ClassVar[int]
+    nrasToken: GetNRASToken
+    topology: GetGPUTopology
+    validateToken: ValidateToken
+    def __init__(self, topology: _Optional[_Union[GetGPUTopology, _Mapping]] = ..., nrasToken: _Optional[_Union[GetNRASToken, _Mapping]] = ..., validateToken: _Optional[_Union[ValidateToken, _Mapping]] = ...) -> None: ...
+
+class NvidiaToken(_message.Message):
+    __slots__ = ["jwt"]
+    JWT_FIELD_NUMBER: _ClassVar[int]
+    jwt: str
+    def __init__(self, jwt: _Optional[str] = ...) -> None: ...
+
+class ValidateToken(_message.Message):
+    __slots__ = ["device", "policy", "token"]
+    DEVICE_FIELD_NUMBER: _ClassVar[int]
+    POLICY_FIELD_NUMBER: _ClassVar[int]
+    TOKEN_FIELD_NUMBER: _ClassVar[int]
+    device: NvidiaDeviceType
+    policy: str
+    token: NvidiaToken
+    def __init__(self, token: _Optional[_Union[NvidiaToken, _Mapping]] = ..., policy: _Optional[str] = ..., device: _Optional[_Union[NvidiaDeviceType, str]] = ...) -> None: ...
+
+class VerificationResult(_message.Message):
+    __slots__ = ["success"]
+    SUCCESS_FIELD_NUMBER: _ClassVar[int]
+    success: bool
+    def __init__(self, success: bool = ...) -> None: ...
+
+class NvidiaDeviceType(int, metaclass=_enum_type_wrapper.EnumTypeWrapper):
+    __slots__ = []

package/py/requirements.txt

@@ -0,0 +1,3 @@
+nv-attestation-sdk==2.3.0
+protobuf
+pynvml