Yes that’s what I was trying so I do not shortchange the output with a field 
with a smaller length.. I could make a 0 length field no problem without 
impacting performance or anything as this is a configuration form and will hold 
at most a record at all times.. but I just got curious about it just in case I 
needed to do something similar on a form that might hold millions of records at 
some point..

It was more a question to learn something from.. not quite a need to feed the 
moment..

I appreciate your views though and your help so far..

Joe

From: Michael Latham 
Sent: Tuesday, April 24, 2012 3:12 PM
Newsgroups: public.remedy.arsystem.general
To: [email protected] 
Subject: Re: Working with ENCRYPT() function...

** 
But wait - are you trying to get the length of the output from the encrypt 
function that you run within Remedy.  If that is the case you can just run the 
LENGTH() function on the field once it is set.  Writing outside code is not 
necessary in that case.  I am trying to cover all scenarios here so use what 
you need toss what you don't. 

Mike



--------------------------------------------------------------------------------
From: [email protected]
To: [email protected]
Subject: RE: Working with ENCRYPT() function...
Date: Tue, 24 Apr 2012 14:17:39 -0400


Hey Joe - Here is some code I ran in Netbeans without error in order to test 
the DES encryption to find the length of the ciphered text.  I added a few 
lines of code to show you the encrypted value and it's length the rest I 
can't/won't take credit for.  You can build workflow to run the java code and 
set a field in your form to the value returned by the length method in the 
code.  Catch the return and use it to do the set fields.   

The code is as follows: 

/*
* To change this template, choose Tools | Templates
* and open the template in the editor.
*/
package mik.test.snippet;

/**
*
* @author mlatham
*/
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;

import javax.crypto.Cipher;
import javax.crypto.KeyGenerator;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.SecretKey;

import 
com.sun.xml.internal.messaging.saaj.packaging.mime.util.BASE64DecoderStream;
import 
com.sun.xml.internal.messaging.saaj.packaging.mime.util.BASE64EncoderStream;

public class EncryptDecryptStringWithDES {
private static Cipher ecipher;
private static Cipher dcipher;
private static SecretKey key;
public static void main(String[] args) {
try {
// generate secret key using DES algorithm
key = KeyGenerator.getInstance("DES").generateKey();
ecipher = Cipher.getInstance("DES");
dcipher = Cipher.getInstance("DES");
// initialize the ciphers with the given key
       ecipher.init(Cipher.ENCRYPT_MODE, key);
       dcipher.init(Cipher.DECRYPT_MODE, key);
       
       String encrypted = encrypt("This is a highly classified message!");
       String decrypted = decrypt(encrypted);
       int length = encrypted.length();
                System.out.println("Encryted:" + encrypted);
       System.out.println("Decrypted: " + decrypted);
                System.out.println("The length of the encrypted string is: " + 
length);
       
}
catch (NoSuchAlgorithmException e) {
System.out.println("No Such Algorithm:" + e.getMessage());
return;
}
catch (NoSuchPaddingException e) {
System.out.println("No Such Padding:" + e.getMessage());
return;
}
catch (InvalidKeyException e) {
System.out.println("Invalid Key:" + e.getMessage());
return;
}
}
public static String encrypt(String str) {
        try {
            
        // encode the string into a sequence of bytes using the named charset
        // storing the result into a new byte array. 
        byte[] utf8 = str.getBytes("UTF8");

            byte[] enc = ecipher.doFinal(utf8);

            // encode to base64
            enc = BASE64EncoderStream.encode(enc);
            
            return new String(enc);
            
        }
        catch (Exception e) {
        }
        return null;
        
    }
public static String decrypt(String str) {
        try {
            
        // decode with base64 to get bytes
            byte[] dec = BASE64DecoderStream.decode(str.getBytes());

            byte[] utf8 = dcipher.doFinal(dec);

            // create new string based on the specified charset
            return new String(utf8, "UTF8");
            
        }
        catch (Exception e) {
        }
        return null;
        
    }

}

END OF CODE


--------------------------------------------------------------------------------
From: [email protected]
To: [email protected]
Subject: RE: Working with ENCRYPT() function...
Date: Mon, 23 Apr 2012 14:32:13 -0400


In general - a character in the English language is represented by 1 byte for 
ASCII and 2 bytes per character for Unicode.  A lot of encoding in the various 
languages is done using Unicode.  So 1 Byte contains 8-16 bits depending on 
whether it is ASCII or Unicode.  

Excuse me for a moment, I need to get caught up on what you are currently doing 
or what your actual issue is.  You take a value which you input yourself and 
use the ENCRYPT function to cipher that value?  You then want to get the length 
of the encrypted value?



--------------------------------------------------------------------------------
Date: Mon, 23 Apr 2012 11:17:02 -0400
From: [email protected]
Subject: Re: Working with ENCRYPT() function...
To: [email protected]

** 

Good to hear from you too Michael.. I’m back in the downtown area these days – 
haven’t worked in this area since we last worked together at Nomura about 7 
years ago. Time flies eh? I’m about 2 or 3 blocks away from there and even 
intend to take lunch at some of those restaurants from that area when the 
weather gets a little more forgiving..

I’m still into Remedy work a bit of consulting and some developing. I kind of 
miss some of the older work we used to get that involved more development than 
customization. I had stayed away from ITSM kind of projects for the longest 
time, until I realized that if I kept staying away from it, I might soon have 
to start looking at an alternative solution to work with. I've had very brief 
opportunities to work with some complimentary products, but stayed with the 
mainstream Remedy products mostly.

As you may have figured out from some of my recent posts, I am currently 
working on an integration effort between Remedy and OIM (Oracle Identity 
Management) using their SPML (web services). I had a sticky pitch for a while, 
but it turned out it was because of some configuration settings from the OIM 
side. They (OIM admins) still haven’t figured out what that discrepancy might 
be but I’ve asked them to investigate the difference between a now working 
instance and the older non working one. This I figure would be useful 
information to have later while building the other production and training 
environments at this site..

Anyways getting back on topic, I’m yet to determine what length I may need to 
hold my encrypted string that holds the OIM configuration password... I have 
currently set it to 120 and for now will resort to the good old trial and error 
method, in the absence of the exact formula to use to determine it. OIM allows 
passwords of no more than length 8 and I have noticed that using an encryption 
key of length 38, a GUID, returns outputs of length averaging in between 75 to 
80.. So I created a field of length 120 to store that, hoping it would not 
cross that value.

Cheers

Joe

From: Michael Latham 
Sent: Monday, April 23, 2012 9:48 AM
Newsgroups: public.remedy.arsystem.general
To: [email protected] 
Subject: Re: Working with ENCRYPT() function...

** 
I have been good Joe.  Just doing the usual Remedy consultant thing. And you?  
I see you are an arslist superstar by looking at your post history.  Cool that 
you stay involved with the community so much.  I wish I had the time!  Take 
care man and stay in touch! 

Mike



--------------------------------------------------------------------------------
Date: Fri, 20 Apr 2012 18:06:38 -0400
From: [email protected]
Subject: Re: Working with ENCRYPT() function...
To: [email protected]

** 
Yes I was interested in the character count as if I encrypted the input, I’d 
need to consider enough room for storage. I was tempted to build a 254 
character field to store it, but then curiosity got the better of me and I 
wanted to know if there was an algorithm to calculate the expected length of 
the encrypted text..

Yes I do remember you from Nomura. How have you been. 

Thank you for the info.. something that I can digest over the weekend..

Joe

From: Michael Latham 
Sent: Friday, April 20, 2012 5:47 PM
Newsgroups: public.remedy.arsystem.general
To: [email protected] 
Subject: Re: Working with ENCRYPT() function...

** 
Hey Joe -

How have things been since Nomura - if you remember me from that project and 
you are in fact the same Joe De'Souza.  

To move along, encryption algorithms vary.  If I am not mistaken Remedy ARS 
uses DES block-cipher encryption in the ENCRYPT function.    DES in and of 
itself is symmetric from an algorithm standpoint. It uses one 64-bit key to 
encrypt a block of plaintext that is 64-bits into ciphered text.  It has one 
parity bit for each byte of the provided key which generates a key strength 
which is only 56-bits.



  Per BMC Documentation:

"The output is limited to the size of the field used for output, including the 
base-64 encoding.
Therefore, you are limited to encrypting a string that is 3/4 the size of the 
output field."

Using the passphrase method as a way to generate the encrypted text is achieved 
using, most probably, a key derivation and salt combination.

In order to decrypt ciphered text you would need to "code" an external DES 
ciphering utility in your language of choice that would encrypt the plain text 
based on the key provided or decrypt the ciphered text using the key provided.  
As long as you have the key you can go back and forth with the 
encryption/decryption.


By the way, why do you need to know the length of the output string?  I am 
assuming when you say length you mean character count or something similar.


Mike








--------------------------------------------------------------------------------
Date: Fri, 20 Apr 2012 13:48:37 -0400
From: [email protected]
Subject: Working with ENCRYPT() function...
To: [email protected]

** 

Is there a known algorithm to calculate the length of the output results of 
ENCRYPT based on the length of the input string and the encryption key 
parameters?

I vaguely remember that the length is 120. Or is that only the length of the 
encrypted value in Field 123?

Also how would one decrypt the contents of Field 123 if that is used for 
storing a password that is used for authenticating into an external app or wsdl?

Joe

_______________________________________________________________________________
UNSUBSCRIBE or access ARSlist Archives at www.arslist.org
attend wwrug12 www.wwrug12.com ARSList: "Where the Answers Are"

Reply via email to