This tutorial guides you through the process of building a sample application using the REST API. The goals for the tutorial are to gain competence and familiarity with the process of developing a DualShield application.

Building a DualShield API application is actually quite simple. There are only 3 basic steps:

Register an API Agent

To DualShield, your application is an API agent. Therefore, the very first step is to register your application as an API Agent in the DualShield authentication server.
To register an agent, you must first create the following objects in DualShield:
  • A domain
  • A realm
  • A logon procedure
  • An application

The type of the logon procedure should be set as "Web SSO"

The logon procedure does not have to contain any logon steps.




To register an API agent, select "Authentication | Agents" in the main menu, then click the "Registration" button in the toolbar.

FieldValue
TypeThe type of the agent must be set to "API Agent".
ApplicationSelect the application that you have created for the agent.
Check Agent IPYou can enable the "Check Agent IP" option for extra security. If this option is selected then you must provide the IP address of the machine where your application is running.
Agent PasswordThe communication protocol between the agent, i.e. your application and the DualShield is always HTTPS, therefore DualShield will create an SSL certificate for the agent. This is the password to be used to secure the agent SSL certificate.
Agent Registration DataThe Agent Registration Data is not required.

Download the API Agent Certificate

As mentioned, the communication protocol between your application and the DualShield is always HTTPS. Therefore you need to download the agent's certificate which will be required in your application codes.
You can use either PKCS12 or PEM certificate in your code.


To download a PEM format certificate, in the Agents list, click the context menu of your agent and select "Download | Agent SSL Certificate (PEM)". The certificate will be saved as "My Application.PEM". This PEM certificate contains both the certificate and the private key.
If you are using some programming language, like python, you might want to extract the private key separately. You can use the OpenSSL tool:

  1. Rename "My application.pem" to "apicert.pem"
  2. In the CMD console, execute:


openssl rsa -in apicert.pem -out apikey.pem


apikey.pem is the certificate's unencrypted private key.


To download a PKCS12 format certificate, select "Download | Agent SSL Certificate (PFX)". Or, if your application code is in JAVA, you can download a JKS store directly by selecting "Download | Agent SSL Certificate (JKS)"

Write an API Application

Test API in Python

Create a DualShield Class

class DualShield:

    headers = {"Content-Type": "application/json"}
    app_context = "/das5/rest/"

    def _init_(self, host, port, keyFile, certFile):
        self.keyFile = keyFile
        self.certFile = certFile
        self.conn = HTTPSConnection(host, port, keyFile, certFile)

    def execute(self, method, params):
        data = json.dumps(params)
        self.conn.request("POST", self.app_context + method, data, self.headers)
        response = self.conn.getresponse()
        data = response.read()
        return json.loads(data.decode('utf-8'))

    def close(self):
        self.conn.close()
        self.conn = None


Initialize DualShield Variables

host = 'dualshield.deepnetlabs.com'
port = 8071
keyFile = 'apikey.pem'
certFile = 'apicert.pem'
domainname='deepnetlabs.com'

Replace the values of these variable with your own.
host: the host name (FQDN) of your DualShield server
port: the port number of the DualShield authentication server
keyFile: Your agent's private key file
certFile: Your agent's certificate file
domainname: The name of the domain that your agent is connected to

Create a Test Class

class TestDualShield(unittest.TestCase):

    def setUp(self):
        self.auth=DualShield(host, port, keyFile, certFile)

    def tearDown(self):
        self.auth.close()


Check the Connection

Call the"Hello" method in DualShield to check the connection

    def test_1_hello(self):
        r=self.auth.execute("auth/hello", {})

Static Password Authentication

The authentication method for verifying Static Password is "SPASS"

    def test_2_staticpass(self):
        #logon with 'static password' credential
        username=raw_input('Please enter your login name:')
        password=raw_input('Please enter your AD password:')
        params = {
            'user':{'loginName':username, 'domain.name':domainname},
            'credential':{'method':'SPASS', 'password':password}
        }
        r=self.auth.execute("auth/verify", params)


One-Time Password Authentication

The authentication method for verifying Static Password is "OTP"

    def test_3_verifySafeID(self):
        otp=raw_input('Please enter you SafeIDotp:')
        params = {
            'user':{'loginName':username, 'domain.name':domainname},
            'credential':{'method':'OTP', 'otp':otp}
        }
        r=self.auth.execute("auth/verify", params)


Deliver On-Demand Password

To deliver an on-demand password to a user via email message (SMTP)

    def test_4_sendOTP(self):
        username=raw_input('Please enter your login name:')
        params = {
            'user':{'loginName':username, 'domain.name':domainname},
            'options':{'channel':'SMTP'}
        }
        r=self.auth.execute("auth/sendOTP", params)


On-Demand Password Authentication

The authentication method for verifying On-Demand Password is "OTPoD"

    def test_5_verifyODP(self):
        username=raw_input('Please enter your login name:')
        otp=raw_input('Please enter you otp:')
        params = {
            'user':{'loginName':username, 'domain.name':domainname},
            'credential':{'method':'OTPoD', 'otp':otp}
        }
        r=self.auth.execute("auth/verify", params)

Test API in Postman

  • No labels