Anyone tried writing a messenger that supports YAHOO protoco

[jrw]

Anyone tried writing a simple messenger which can talk to YAHOO messenger clients?, I was look at http://libyahoo2.sourceforge.net/ but Im not a c++ programmer.

TIA

[omid-xp]

I need to this too.

If somebody write an Userlibrary for yahoo messenger it's be cool.

Sample :

I want open one new private window and send one message to an user .

How must do this ?

Dll ? Api ? shortcut keys ?

[jrw]

I found some information on YMSG9 protocol but I believe the latest protocol used by YAHOO beta 6 messenger is YMSG12. Anyway maybe someone will find this a little helpful if I dont get anytime to get this working in purebasic

OK, first thing we need to do is connect to a Yahoo YMSG server. For the purpose of this tutorial we shall use scs.msg.sc5.yahoo.com and port 5050 as this is the usual port used by the YMSG protocol.

Right the first packet we send is to check that the server is a YMSG9 server, and the packet we send is :-

"YMSG" 09 00 00 00 00 00 00 "L" 00 00 00 00 00 00 00 00

If the server is a YMSG server is replies with the same packet. Now we can request the challenge string and session ID. The challenge string is used for encrypting the password while the session ID is sent with every packet.
The packet we send to retrieve these is :-

"YMSG" 09 00 00 00 SIZE 00 "W" 00 00 00 00 00 00 00 00 "1" C0 80 USERNAME C0 80

You will notice the SIZE part of the packet. This is 2 bytes (characters) that represent the size of the packets payload. The payload in laymans terms is the size of the packet - 20. The format for the size is A B where A is the number of times 255 will go into the size of the payload and B is the remainder. Username is self explanatory.
Ok the packet returned by the server contains both the challenge string and our session ID. The challenge string is found at the end of the packet sandwiched between CO 80 and C0 80. The session ID is characters 17 to 20 (4 characters in length, starting at and including character 17)

Now we have our challenge string and the session ID we need to encrypt the password. For this you will need a dll or encryption function written for this very purpose.

Once you have got your 2, yes 2, encrypted strings we send them in this packet :-

"YMSG" 09 00 00 00 SIZE 00 "T" 00 00 00 0C "KMND" 00 C0 80 USERNAME C0 80 "6" C0 80 ENCODEDSTRING1 C0 80 "96" C0 80 ENCODEDSTRING2 C0 80 "2" C0 80 "1" C0 80 "1" C0 80 USERNAME C0 80

The packet sent back to us (provided the password is correct and there hasn't been an error in the encryption) contains the accounts usernames, ignore list, buddy list, and cookies.

Now we need to set our status as Available :-

"YMSG" 09 00 00 00 00 00 00 04 00 00 00 0C 00 00 00 00

The server now tells us which of our buddies are online and what their status is. Now we can send and recieve IM's and any other none chat related messenger packets.

Now just to get you started I'll give you the packet to send an Instant Message :-

"YMSG" 09 00 00 00 SIZE 00 06 5A 55 AA 56 SESSIONID "1" CO 80 USERNAME C0 80 "5" C0 80 CO 80 OTHERPERSON C0 80 "14" C0 80 MESSAGE C0 80

The Yahoo Messenger Protocol is an application layer protocol running most of the time over TCP, but in some cases over HTTP as well. Throughout this document, we will speak about the YMSG packets, after stripping out any other protocol data, but will mention this other data if it is of relevance.


1. The YMSG packet structure

The YMSG packet structure is as follows:

(each byte is represented by 5 spaces in the following diagram,
including the | at the end)

<------- 4B -------><------- 4B -------><---2B--->
+-------------------+-------------------+---------+
| Y M S G | version | pkt_len |
+---------+---------+---------+---------+---------+
| service | status | session_id |
+---------+-------------------+-------------------+
| |
: D A T A :
| 0 - 65535* |
+-------------------------------------------------+


* 65535 is the theoretical limit, since the length field is two bytes
long. Practically though, the data section does not exceed about 1000
bytes.

All numeric fields are stored in network byte order. i.e. Most
significant byte first.

YMSG - The first four bytes of all packets are always YMSG - the
protocol name.

version - The next four bytes are for the protocol version number.
For version 9, these are 0x09 0x00 0x00 0x00
NOTE: The last three bytes of this may just be padding bytes.

pkt_len - A two byte value, in network byte order, stating how many bytes
are in the _data_ section of the packet. In practice, this
value does not exceed about 1000.

service - This is an opcode that tells the client/server what kind of
service is requested/being responded to. There are 45 known
services. See the services section of this document for a
full listing.

status - In case of a response from the server, indicates the status
of the request (success/failure/etc.). For a request, it is 0
in most cases, except for packets that set the user's status
(set status, typing notify, etc.)

session - The session id is used primarily when connecting through a HTTP
id proxy. It is set in all cases, but has no effect in a direct
connection. When the client sends the first packet, it is 0,
the server responds with a session id that is used by the client
and the server in all further packets. The server may change
the session id, in which case the client must use the new
session id henceforth.

DATA - The data section is pkt_len bytes long and consists of a series
of key/value pairs. All keys are numeric strings. The packet
contains their numeric values in the ASCII character set. e.g.
1 == 0x31, 21 == 0x32 0x31

The maximum number of digits in a key is unknown, although keys
of up to three digits have been seen.

Every key and value is terminated by a two byte sequence of
0xc0 0x80. Some keys may have empty values.

The actual keys sent, and their meanings depend on the service
in use.

e.g. The packet data to send an instant message looks like this:

0x30 0xc080 yahoo_id 0xc080 0x31 0xc080 active_id 0xc080 0x35
0xc080 recipient_id 0xc080 0x3134 0xc080 message_text 0xc080

The 0xc080 byte sequence is a separator. The values 0x30, 0x31,
0x35 and 0x3134 are the keys. Convert them to their ASCII
equivalents and you get 0, 1, 5, 14 (0x3134 == 0x31 0x34)


2. Services

There are 45 known services at the moment, although more may exist. All
known services are listed below along with the hex values that they
correspond to. Any service without a hex value is one more than the
previous value. i.e. YAHOO_SERVICE_LOGOFF=0x02 and
YAHOO_SERVICE_ISBACK=0x04.

YAHOO_SERVICE_LOGON = 0x01
YAHOO_SERVICE_LOGOFF
YAHOO_SERVICE_ISAWAY
YAHOO_SERVICE_ISBACK
YAHOO_SERVICE_IDLE = 0x05
YAHOO_SERVICE_MESSAGE
YAHOO_SERVICE_IDACT
YAHOO_SERVICE_IDDEACT
YAHOO_SERVICE_MAILSTAT
YAHOO_SERVICE_USERSTAT = 0x0a
YAHOO_SERVICE_NEWMAIL
YAHOO_SERVICE_CHATINVITE
YAHOO_SERVICE_CALENDAR
YAHOO_SERVICE_NEWPERSONALMAIL
YAHOO_SERVICE_NEWCONTACT = 0x0f
YAHOO_SERVICE_ADDIDENT = 0x10
YAHOO_SERVICE_ADDIGNORE
YAHOO_SERVICE_PING
YAHOO_SERVICE_GROUPRENAME
YAHOO_SERVICE_SYSMESSAGE = 0x14
YAHOO_SERVICE_PASSTHROUGH2 = 0x16
YAHOO_SERVICE_CONFINVITE = 0x18
YAHOO_SERVICE_CONFLOGON
YAHOO_SERVICE_CONFDECLINE = 0x1a
YAHOO_SERVICE_CONFLOGOFF
YAHOO_SERVICE_CONFADDINVITE
YAHOO_SERVICE_CONFMSG
YAHOO_SERVICE_CHATLOGON
YAHOO_SERVICE_CHATLOGOFF = 0x1f
YAHOO_SERVICE_CHATMSG = 0x20
YAHOO_SERVICE_GAMELOGON = 0x28
YAHOO_SERVICE_GAMELOGOFF
YAHOO_SERVICE_GAMEMSG = 0x2a
YAHOO_SERVICE_FILETRANSFER = 0x46
YAHOO_SERVICE_VOICECHAT = 0x4a
YAHOO_SERVICE_NOTIFY = 0x4b
YAHOO_SERVICE_P2PFILEXFER = 0x4d
YAHOO_SERVICE_PEERTOPEER = 0x4f
YAHOO_SERVICE_AUTHRESP = 0x54
YAHOO_SERVICE_LIST = 0x55
YAHOO_SERVICE_AUTH = 0x57
YAHOO_SERVICE_ADDBUDDY = 0x83
YAHOO_SERVICE_REMBUDDY = 0x84
YAHOO_SERVICE_IGNORECONTACT = 0x85
YAHOO_SERVICE_REJECTCONTACT = 0x86

Most of the service codes should be self explanatory. Those that aren't
are listed here:

IDACT/IDDEACT - activate/deactivate an identity
NOTIFY - typing/game notification
FILETRASNFER - transfer a file using the yahoo filetransfer server as an
intermediate
P2PFILEXFER - transfer a file between two peers, yahoo server not used
PEERTOPEER - check if peer to peer connections are possible
AUTH - Send initial login packet (username), response contains
challenge string
AUTHRESP - Send response to challenge string, or, if received from
server, contains reason for login failure
LOGON/LOGOFF - a buddy logged in/out


3. Status codes

The status code is a four byte value. Most status codes are two bytes
long. The status codes (in decimal except for offline and typing) are:

YAHOO_STATUS_AVAILABLE = 0
YAHOO_STATUS_BRB
YAHOO_STATUS_BUSY
YAHOO_STATUS_NOTATHOME
YAHOO_STATUS_NOTATDESK
YAHOO_STATUS_NOTINOFFICE = 5
YAHOO_STATUS_ONPHONE
YAHOO_STATUS_ONVACATION
YAHOO_STATUS_OUTTOLUNCH
YAHOO_STATUS_STEPPEDOUT = 9
YAHOO_STATUS_INVISIBLE = 12
YAHOO_STATUS_CUSTOM = 99
YAHOO_STATUS_IDLE = 999
YAHOO_STATUS_OFFLINE = 0x5a55aa56
YAHOO_STATUS_TYPING = 0x16

You may choose either AVAILABLE or INVISIBLE as your initial login status.
TYPING is used only when sending a TYPING notification packet.


4. Session states

A Yahoo session has two states, Authentication and Messaging.

4.1. Authentication

The session starts in the authentication state. The client sends the username
to the server. The server responds with a challenge string. The client
responds to this challenge with two response strings. If authentication is
successful, the connection goes into the messaging state, else, an error
response is sent back.

[jrw]

I believe the new authentication uses MD5 to encrypt your yahoo password accross the internet. I found some VB6 code so thats some code to try and convert to pb

Code: Select all

This is VB6 code!!.. to be converted to purebasic :)
VERSION 1.0 CLASS
BEGIN
  MultiUse = -1  'True
  Persistable = 0  'NotPersistable
  DataBindingBehavior = 0  'vbNone
  DataSourceBehavior  = 0  'vbNone
  MTSTransactionMode  = 0  'NotAnMTSObject
END
Attribute VB_Name = "MD5"
Attribute VB_GlobalNameSpace = False
Attribute VB_Creatable = True
Attribute VB_PredeclaredId = False
Attribute VB_Exposed = False
Option Explicit

'=
'= Class Constants
'=
Private Const OFFSET_4 = 4294967296#
Private Const MAXINT_4 = 2147483647

Private Const S11 = 7
Private Const S12 = 12
Private Const S13 = 17
Private Const S14 = 22
Private Const S21 = 5
Private Const S22 = 9
Private Const S23 = 14
Private Const S24 = 20
Private Const S31 = 4
Private Const S32 = 11
Private Const S33 = 16
Private Const S34 = 23
Private Const S41 = 6
Private Const S42 = 10
Private Const S43 = 15
Private Const S44 = 21


'=
'= Class Variables
'=
Private State(4) As Long
Private ByteCounter As Long
Private ByteBuffer(63) As Byte


'=
'= Class Properties
'=
Property Get RegisterA() As String
    RegisterA = State(1)
End Property

Property Get RegisterB() As String
    RegisterB = State(2)
End Property

Property Get RegisterC() As String
    RegisterC = State(3)
End Property

Property Get RegisterD() As String
    RegisterD = State(4)
End Property


'=
'= Class Functions
'=

'
' Function to quickly digest a file into a hex string
'
Public Function DigestFileToHexStr(FileName As String) As String
    Open FileName For Binary Access Read As #1
    MD5Init
    Do While Not EOF(1)
        Get #1, , ByteBuffer
        If Loc(1) < LOF(1) Then
            ByteCounter = ByteCounter + 64
            MD5Transform ByteBuffer
        End If
    Loop
    ByteCounter = ByteCounter + (LOF(1) Mod 64)
    Close #1
    MD5Final
    DigestFileToHexStr = GetValues
End Function

'
' Function to digest a text string and output the result as a string
' of hexadecimal characters.
'
Public Function DigestStrToHexStr(SourceString As String) As String
    MD5Init
    MD5Update Len(SourceString), StringToArray(SourceString)
    MD5Final
    DigestStrToHexStr = GetValues
End Function

'
' A utility function which converts a string into an array of
' bytes.
'
Private Function StringToArray(InString As String) As Byte()
    Dim i As Integer
    Dim bytBuffer() As Byte
    ReDim bytBuffer(Len(InString))
    For i = 0 To Len(InString) - 1
        bytBuffer(i) = Asc(Mid(InString, i + 1, 1))
    Next i
    StringToArray = bytBuffer
End Function

'
' Concatenate the four state vaules into one string
'
Public Function GetValues() As String
    GetValues = LongToString(State(1)) & LongToString(State(2)) & LongToString(State(3)) & LongToString(State(4))
End Function

'
' Convert a Long to a Hex string
'
Private Function LongToString(Num As Long) As String
        Dim a As Byte
        Dim b As Byte
        Dim c As Byte
        Dim d As Byte
        
        a = Num And &HFF&
        If a < 16 Then
            LongToString = "0" & Hex(a)
        Else
            LongToString = Hex(a)
        End If
               
        b = (Num And &HFF00&) \ 256
        If b < 16 Then
            LongToString = LongToString & "0" & Hex(b)
        Else
            LongToString = LongToString & Hex(b)
        End If
        
        c = (Num And &HFF0000) \ 65536
        If c < 16 Then
            LongToString = LongToString & "0" & Hex(c)
        Else
            LongToString = LongToString & Hex(c)
        End If
       
        If Num < 0 Then
            d = ((Num And &H7F000000) \ 16777216) Or &H80&
        Else
            d = (Num And &HFF000000) \ 16777216
        End If
        
        If d < 16 Then
            LongToString = LongToString & "0" & Hex(d)
        Else
            LongToString = LongToString & Hex(d)
        End If
    
End Function

'
' Initialize the class
'   This must be called before a digest calculation is started
'
Public Sub MD5Init()
    ByteCounter = 0
    State(1) = UnsignedToLong(1732584193#)
    State(2) = UnsignedToLong(4023233417#)
    State(3) = UnsignedToLong(2562383102#)
    State(4) = UnsignedToLong(271733878#)
End Sub

'
' MD5 Final
'
Public Sub MD5Final()
    Dim dblBits As Double
    
    Dim padding(72) As Byte
    Dim lngBytesBuffered As Long
    
    padding(0) = &H80
    
    dblBits = ByteCounter * 8
    
    ' Pad out
    lngBytesBuffered = ByteCounter Mod 64
    If lngBytesBuffered <= 56 Then
        MD5Update 56 - lngBytesBuffered, padding
    Else
        MD5Update 120 - ByteCounter, padding
    End If
    
    
    padding(0) = UnsignedToLong(dblBits) And &HFF&
    padding(1) = UnsignedToLong(dblBits) \ 256 And &HFF&
    padding(2) = UnsignedToLong(dblBits) \ 65536 And &HFF&
    padding(3) = UnsignedToLong(dblBits) \ 16777216 And &HFF&
    padding(4) = 0
    padding(5) = 0
    padding(6) = 0
    padding(7) = 0
    
    MD5Update 8, padding
End Sub

'
' Break up input stream into 64 byte chunks
'
Public Sub MD5Update(InputLen As Long, InputBuffer() As Byte)
    Dim II As Integer
    Dim i As Integer
    Dim J As Integer
    Dim K As Integer
    Dim lngBufferedBytes As Long
    Dim lngBufferRemaining As Long
    Dim lngRem As Long
    
    lngBufferedBytes = ByteCounter Mod 64
    lngBufferRemaining = 64 - lngBufferedBytes
    ByteCounter = ByteCounter + InputLen
    ' Use up old buffer results first
    If InputLen >= lngBufferRemaining Then
        For II = 0 To lngBufferRemaining - 1
            ByteBuffer(lngBufferedBytes + II) = InputBuffer(II)
        Next II
        MD5Transform ByteBuffer
        
        lngRem = (InputLen) Mod 64
        ' The transfer is a multiple of 64 lets do some transformations
        For i = lngBufferRemaining To InputLen - II - lngRem Step 64
            For J = 0 To 63
                ByteBuffer(J) = InputBuffer(i + J)
            Next J
            MD5Transform ByteBuffer
        Next i
        lngBufferedBytes = 0
    Else
      i = 0
    End If
    
    ' Buffer any remaining input
    For K = 0 To InputLen - i - 1
        ByteBuffer(lngBufferedBytes + K) = InputBuffer(i + K)
    Next K
    
End Sub

'
' MD5 Transform
'
Private Sub MD5Transform(Buffer() As Byte)
    Dim X(16) As Long
    Dim a As Long
    Dim b As Long
    Dim c As Long
    Dim d As Long
    
    a = State(1)
    b = State(2)
    c = State(3)
    d = State(4)
    
    Decode 64, X, Buffer

    ' Round 1
    FF a, b, c, d, X(0), S11, -680876936
    FF d, a, b, c, X(1), S12, -389564586
    FF c, d, a, b, X(2), S13, 606105819
    FF b, c, d, a, X(3), S14, -1044525330
    FF a, b, c, d, X(4), S11, -176418897
    FF d, a, b, c, X(5), S12, 1200080426
    FF c, d, a, b, X(6), S13, -1473231341
    FF b, c, d, a, X(7), S14, -45705983
    FF a, b, c, d, X(8), S11, 1770035416
    FF d, a, b, c, X(9), S12, -1958414417
    FF c, d, a, b, X(10), S13, -42063
    FF b, c, d, a, X(11), S14, -1990404162
    FF a, b, c, d, X(12), S11, 1804603682
    FF d, a, b, c, X(13), S12, -40341101
    FF c, d, a, b, X(14), S13, -1502002290
    FF b, c, d, a, X(15), S14, 1236535329
    
    ' Round 2
    GG a, b, c, d, X(1), S21, -165796510
    GG d, a, b, c, X(6), S22, -1069501632
    GG c, d, a, b, X(11), S23, 643717713
    GG b, c, d, a, X(0), S24, -373897302
    GG a, b, c, d, X(5), S21, -701558691
    GG d, a, b, c, X(10), S22, 38016083
    GG c, d, a, b, X(15), S23, -660478335
    GG b, c, d, a, X(4), S24, -405537848
    GG a, b, c, d, X(9), S21, 568446438
    GG d, a, b, c, X(14), S22, -1019803690
    GG c, d, a, b, X(3), S23, -187363961
    GG b, c, d, a, X(8), S24, 1163531501
    GG a, b, c, d, X(13), S21, -1444681467
    GG d, a, b, c, X(2), S22, -51403784
    GG c, d, a, b, X(7), S23, 1735328473
    GG b, c, d, a, X(12), S24, -1926607734
    
    ' Round 3
    HH a, b, c, d, X(5), S31, -378558
    HH d, a, b, c, X(8), S32, -2022574463
    HH c, d, a, b, X(11), S33, 1839030562
    HH b, c, d, a, X(14), S34, -35309556
    HH a, b, c, d, X(1), S31, -1530992060
    HH d, a, b, c, X(4), S32, 1272893353
    HH c, d, a, b, X(7), S33, -155497632
    HH b, c, d, a, X(10), S34, -1094730640
    HH a, b, c, d, X(13), S31, 681279174
    HH d, a, b, c, X(0), S32, -358537222
    HH c, d, a, b, X(3), S33, -722521979
    HH b, c, d, a, X(6), S34, 76029189
    HH a, b, c, d, X(9), S31, -640364487
    HH d, a, b, c, X(12), S32, -421815835
    HH c, d, a, b, X(15), S33, 530742520
    HH b, c, d, a, X(2), S34, -995338651
    
    ' Round 4
    II a, b, c, d, X(0), S41, -198630844
    II d, a, b, c, X(7), S42, 1126891415
    II c, d, a, b, X(14), S43, -1416354905
    II b, c, d, a, X(5), S44, -57434055
    II a, b, c, d, X(12), S41, 1700485571
    II d, a, b, c, X(3), S42, -1894986606
    II c, d, a, b, X(10), S43, -1051523
    II b, c, d, a, X(1), S44, -2054922799
    II a, b, c, d, X(8), S41, 1873313359
    II d, a, b, c, X(15), S42, -30611744
    II c, d, a, b, X(6), S43, -1560198380
    II b, c, d, a, X(13), S44, 1309151649
    II a, b, c, d, X(4), S41, -145523070
    II d, a, b, c, X(11), S42, -1120210379
    II c, d, a, b, X(2), S43, 718787259
    II b, c, d, a, X(9), S44, -343485551
    
    
    State(1) = LongOverflowAdd(State(1), a)
    State(2) = LongOverflowAdd(State(2), b)
    State(3) = LongOverflowAdd(State(3), c)
    State(4) = LongOverflowAdd(State(4), d)

'  /* Zeroize sensitive information.
'*/
'  MD5_memset ((POINTER)x, 0, sizeof (x));
    
End Sub

Private Sub Decode(Length As Integer, OutputBuffer() As Long, InputBuffer() As Byte)
    Dim intDblIndex As Integer
    Dim intByteIndex As Integer
    Dim dblSum As Double
    
    intDblIndex = 0
    For intByteIndex = 0 To Length - 1 Step 4
        dblSum = InputBuffer(intByteIndex) + _
                                    InputBuffer(intByteIndex + 1) * 256# + _
                                    InputBuffer(intByteIndex + 2) * 65536# + _
                                    InputBuffer(intByteIndex + 3) * 16777216#
        OutputBuffer(intDblIndex) = UnsignedToLong(dblSum)
        intDblIndex = intDblIndex + 1
    Next intByteIndex
End Sub

'
' FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
' Rotation is separate from addition to prevent recomputation.
'
Private Function FF(a As Long, _
                    b As Long, _
                    c As Long, _
                    d As Long, _
                    X As Long, _
                    s As Long, _
                    ac As Long) As Long
    a = LongOverflowAdd4(a, (b And c) Or (Not (b) And d), X, ac)
    a = LongLeftRotate(a, s)
    a = LongOverflowAdd(a, b)
End Function

Private Function GG(a As Long, _
                    b As Long, _
                    c As Long, _
                    d As Long, _
                    X As Long, _
                    s As Long, _
                    ac As Long) As Long
    a = LongOverflowAdd4(a, (b And d) Or (c And Not (d)), X, ac)
    a = LongLeftRotate(a, s)
    a = LongOverflowAdd(a, b)
End Function

Private Function HH(a As Long, _
                    b As Long, _
                    c As Long, _
                    d As Long, _
                    X As Long, _
                    s As Long, _
                    ac As Long) As Long
    a = LongOverflowAdd4(a, b Xor c Xor d, X, ac)
    a = LongLeftRotate(a, s)
    a = LongOverflowAdd(a, b)
End Function

Private Function II(a As Long, _
                    b As Long, _
                    c As Long, _
                    d As Long, _
                    X As Long, _
                    s As Long, _
                    ac As Long) As Long
    a = LongOverflowAdd4(a, c Xor (b Or Not (d)), X, ac)
    a = LongLeftRotate(a, s)
    a = LongOverflowAdd(a, b)
End Function

'
' Rotate a long to the right
'
Function LongLeftRotate(value As Long, bits As Long) As Long
    Dim lngSign As Long
    Dim lngI As Long
    bits = bits Mod 32
    If bits = 0 Then LongLeftRotate = value: Exit Function
    For lngI = 1 To bits
        lngSign = value And &HC0000000
        value = (value And &H3FFFFFFF) * 2
        value = value Or ((lngSign < 0) And 1) Or (CBool(lngSign And _
                &H40000000) And &H80000000)
    Next
    LongLeftRotate = value
End Function

'
' Function to add two unsigned numbers together as in C.
' Overflows are ignored!
'
Private Function LongOverflowAdd(Val1 As Long, Val2 As Long) As Long
    Dim lngHighWord As Long
    Dim lngLowWord As Long
    Dim lngOverflow As Long

    lngLowWord = (Val1 And &HFFFF&) + (Val2 And &HFFFF&)
    lngOverflow = lngLowWord \ 65536
    lngHighWord = (((Val1 And &HFFFF0000) \ 65536) + ((Val2 And &HFFFF0000) \ 65536) + lngOverflow) And &HFFFF&
    LongOverflowAdd = UnsignedToLong((lngHighWord * 65536#) + (lngLowWord And &HFFFF&))
End Function

'
' Function to add two unsigned numbers together as in C.
' Overflows are ignored!
'
Private Function LongOverflowAdd4(Val1 As Long, Val2 As Long, val3 As Long, val4 As Long) As Long
    Dim lngHighWord As Long
    Dim lngLowWord As Long
    Dim lngOverflow As Long

    lngLowWord = (Val1 And &HFFFF&) + (Val2 And &HFFFF&) + (val3 And &HFFFF&) + (val4 And &HFFFF&)
    lngOverflow = lngLowWord \ 65536
    lngHighWord = (((Val1 And &HFFFF0000) \ 65536) + _
                   ((Val2 And &HFFFF0000) \ 65536) + _
                   ((val3 And &HFFFF0000) \ 65536) + _
                   ((val4 And &HFFFF0000) \ 65536) + _
                   lngOverflow) And &HFFFF&
    LongOverflowAdd4 = UnsignedToLong((lngHighWord * 65536#) + (lngLowWord And &HFFFF&))
End Function

'
' Convert an unsigned double into a long
'
Private Function UnsignedToLong(value As Double) As Long
        If value < 0 Or value >= OFFSET_4 Then Error 6 ' Overflow
        If value <= MAXINT_4 Then
          UnsignedToLong = value
        Else
          UnsignedToLong = value - OFFSET_4
        End If
      End Function

'
' Convert a long to an unsigned Double
'
Private Function LongToUnsigned(value As Long) As Double
        If value < 0 Then
          LongToUnsigned = value + OFFSET_4
        Else
          LongToUnsigned = value
        End If
End Function

[omid-xp]

This is very good help jrw.

But how can we decrypt encrypted password of yahoo messenger ?

[jrw]

No when you login to yahoo messenger it sends your password to the authentication server encrypted in MD5 form because the yahoo authentication server stores the password in MD5 format.

[omid-xp]

Yes, but i want decrypt encrypted password stored in registry for use default user and password in my app .

How decrypt that ?

[vertexfire]

decrypt!!!!

[pdwyer]

Yes, but i want decrypt encrypted password stored in registry for use default user and password in my app .

How decrypt that ?

You already have the pwd, just put it in the registry. to keep it safe on the internet you don't send the actual pwd you just the MD5 fingerprint (assuming the above is correct). MD5 is not reversable (in theory) so since yahoo knows your pwd when you registered then it just compares the MD5s for a match.

(the problem with this of course is that you are always sending the same MD5 so if you sniff someone elses md5 pwd then even though you can't find out what their pwd is, you can still log on just by knowing this and sending it. Therefore I suspect that there's something more to the pwd encryption than just MD5. Generally challenge response is not that easy to bypass and the challenge is a key send to use to encrypt the pwd so every time a different response is sent)