http://www.microsoft.com/technet/security/advisory/2607712.mspx

Before you continue with creating your own solution to removign DigiNotar, review this recent update from Microsoft for an out-of-band update: http://support.microsoft.com/kb/2607712.

The code below will remove certificates containing the word “DigiNotar” in the SubjectName field. The code iterates all certificates in the following stores, in this order, using nearly identical blocks of code:

1. REMOVES *DigiNotar* in the Intermediate certificates store for Current User
2. REMOVES *DigiNotar*in the Intermediate certificates store on Local Machine
3. REMOVES *DigiNotar*in the Trusted “Root” certificate store for Current User
4. REMOVES *DigiNotar*in the Trusted “Root” certificate store on Local Machine

The code removes certificates from both the current user and local machine. Obviously, the local machine will require administrative permissions and the current user will need to be ran on every user. For deployment, you would need to run for each user in their context on every system and once for each system for the root certificate. If you are only concerned with the root certificate, then remove the blocks of code that reference current user.

As with all of my blog articles, there is no warranty or guarantee from the sample provided below. The security of your environment is your responsibility. If the code does not work or causes other issues in your environment, it is your responsibility. You should thorough test prior to release to a production environment.

Removing DigiNotar certificates .NET Framework 2.0 code example:

Imports System
Imports System.Security.Cryptography
Imports System.Security.Cryptography.X509Certificates
Imports System.IO

Module Module1
Dim certsRemoved As Boolean = False
Dim myExitCode As Integer = 0
‘exit code table
’0 = cert removed
’1 = nothing removed
’2 = error

Sub Main()
Console.WriteLine(“devtrends.com — September 2, 2011″)
Console.WriteLine(“Removes DigiNotar* from the Root and CertificateAuthority (Intermediate) certificate store.”)
Console.WriteLine(“”)

’1. REMOVES DigiNotar in the Intermediate certificates store for Current User
Try
‘open a connection to the X509 local certificate store.
Dim store As X509Store = New X509Store(X509Certificates.StoreName.CertificateAuthority, StoreLocation.CurrentUser)
store.Open(OpenFlags.ReadWrite)

‘loop through and find the cert we want to work with
For Each cert As X509Certificate2 In store.Certificates
‘Console.WriteLine(cert.SubjectName.Name)
If (cert.SubjectName.Name.Contains(“DigiNotar”)) Then
Console.WriteLine(“User Intermediate Removed: ” & cert.SubjectName.Name)
store.Remove(cert)
certsRemoved = True
End If
Next

‘close the store object
store.Close()

‘did we remove anything?
If certsRemoved Then
myExitCode = 0
Else
myExitCode = 1
Console.WriteLine(“User Intermediate: DigiNotar not found. Nothing removed.”)
End If
Catch ex As Exception
Console.WriteLine(“User Intermediate Error: ” & ex.Message)
myExitCode = 2
End Try

’2. REMOVES DigiNotar in the Intermediate certificates store on Local Machine
Try
‘open a connection to the X509 local certificate store.
Dim store As X509Store = New X509Store(X509Certificates.StoreName.CertificateAuthority, StoreLocation.LocalMachine)
store.Open(OpenFlags.ReadWrite)

‘loop through and find the cert we want to work with
For Each cert As X509Certificate2 In store.Certificates
‘Console.WriteLine(cert.SubjectName.Name)
If (cert.SubjectName.Name.Contains(“DigiNotar”)) Then
Console.WriteLine(“Local Machine Intermediate Removed: ” & cert.SubjectName.Name)
store.Remove(cert)
certsRemoved = True
End If
Next

‘close the store object
store.Close()

‘did we remove anything?
If certsRemoved Then
myExitCode = 0
Else
myExitCode = 1
Console.WriteLine(“Local Machine Intermediate: DigiNotar not found. Nothing removed.”)
End If
Catch ex As Exception
Console.WriteLine(“Local Machine Intermediate Error: ” & ex.Message)
myExitCode = 2
End Try

’3. REMOVES DigiNotar in the Trusted “Root” certificate store for Current User
Try
‘open a connection to the X509 local certificate store.
Dim store As X509Store = New X509Store(X509Certificates.StoreName.Root, StoreLocation.CurrentUser)
store.Open(OpenFlags.ReadWrite)

‘loop through and find the cert we want to work with
For Each cert As X509Certificate2 In store.Certificates
If (cert.SubjectName.Name.Contains(“DigiNotar”)) Then
Console.WriteLine(“User Root Removed: ” & cert.SubjectName.Name)
store.Remove(cert)
certsRemoved = True
End If
Next
‘close the store object

store.Close()
‘did we remove anything?
If certsRemoved Then
myExitCode = 0
Else
myExitCode = 1
Console.WriteLine(“User Root: DigiNotar not found. Nothing removed.”)
End If
Catch ex As Exception
Console.WriteLine(“User Root Error: ” & ex.Message)
myExitCode = 2
End Try

’4. REMOVES DigiNotar in the Trusted “Root” certificate store on Local Machine
Try
‘open a connection to the X509 local certificate store.
Dim store As X509Store = New X509Store(X509Certificates.StoreName.Root, StoreLocation.LocalMachine)
store.Open(OpenFlags.ReadWrite)

‘loop through and find the cert we want to work with
For Each cert As X509Certificate2 In store.Certificates
If (cert.SubjectName.Name.Contains(“DigiNotar”)) Then
Console.WriteLine(“Local Machine Root Removed: ” & cert.SubjectName.Name)
store.Remove(cert)
certsRemoved = True
End If
Next

‘close the store object
store.Close()

‘did we remove anything?
If certsRemoved Then
myExitCode = 0
Else
myExitCode = 1
Console.WriteLine(“Local Machine Root: DigiNotar not found. Nothing removed.”)
End If
Catch ex As Exception
Console.WriteLine(“Local Machine Root Error: ” & ex.Message)
myExitCode = 2
End Try

‘exit with specific exit code
Console.WriteLine(“”)
Console.WriteLine(“Exit code: (” & myExitCode & “)”)
Environment.Exit(myExitCode)
End Sub

End Module

When I first started the project, I was hoping that my script would run prior to showing the desktop. This is important because if it runs while the user has access to the desktop, that user may start using files that would prevent the script from running correctly (file locks). I had no luck; if anyone has an idea on how to do this, let me know. Otherwise, I created a .NET application that covers the entire screen on the primary monitor (if more than 1 monitor, then the second one is still visible).

BlankScreen

The BlankScreen application is written in VisualStudio .NET 2008 using .NET Framework 2.0 if I remember correctly. There are some changes you may want to make on this application to tailor it for your environment. The first change would be to put your logo on the application form. The second change, and really the more important change, is to change the ProcessPath variable to point to the UNC path of where you plan on putting the desktop.vbs file. This application just runs the VBScript.

So you might be thinking, why would you have an application that is capable of much more advanced programming run a VBScript? Well, I wrote the script first and didn’t feel like porting it to VB.NET. If you feel like spending the time, go for it.

desktop.vbs

Enough chatter about the other stuff, on to the real product of this blog post, the VBScript.

The VBScript has four basic functions that it completes one after the other based on the success of the previous function. Step 1 is to get the username of the logged in user. Step 2 is to create the folders in the user’s My Documents location and copy the files into that new folders (nothing is moved). Step 3 is to update the registry for the Desktop and Favorites locations to the newly created folders. Step 4 renames the old folders in the C:\Documents and Settings\[user]\ folder to DesktopOLD and FavoritesOLD. I feared losing user files, so I did not make the script perform anything that couldn’t be reversed.

Just as you had to change a string variable in the BlankScreen application for your specific server, you also have to change the location of your user’s folder on the network. In my case it was \\fileserver\users\.

The migration will change the registry keys:

HKCR\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders, Favorites
HKCR\Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders, Desktop
HKCR\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders, Favorites
HKCR\Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders, Desktop

The new locations will look something like this:

Desktop: \\[server]\[share]\[username]\Desktop-[username]
Favorites: \\[server]\[share]\[username]\Favorites-[username]
e.g. \\fileserver\users\aaron\Desktop-aaron\ would be my desktop folder.

Conclusion

Implementing this solution is fairly easy. First modify the VB.NET application and compile it. Place the .exe file in a shared location that your login script for users has permissions. Place the VBScript file in a similar location, as you specified in the VB.NET application, and modify the serverpath variable and email variables. Test with your user account in your login script batch file using something similar to below:

if %USERNAME% == yourusername (
 rem lets make sure the user has a my documents folder prior to trying to migrate their desktop
 if exist "\\[server]\Users\%USERNAME%" (
  if exist "C:\Documents and Settings\%USERNAME%\Desktop" (
   rem lets make sure they have the 2.0 Framework installed.
   if exist "C:\Windows\Microsoft.Net\Framework\v2.0*" (
    start "Desktop Migration" "\\[server]\[share]\blankscreen.exe"
   )
  )
 )
)

As a disclaimer, the application AND script are provided without any warranty and is only for educational / informational purposes. If you choose to use it in your environment, production or not, the outcome is your responsibility.

desktop.vbs Code

On Error Resume Next

'alert user of what is happening...
MsgBox "Please click OK to begin the backup process for your Desktop and Internet Explorer Favorites.  This process could take a few minutes, please be patient and Do NOT Cancel anything, otherwise data could be lost!" & vbCrLf & vbCrLf & "If you have Administrator privileges, your computer will restart after all of your files have been copied!"

'get the current user
user = getUser()
'set the server location, the following \ is required!
serverpath = "\\[server]\Users\"
'if you have a helpdesk solution with email capability:
useemailnotify = 0
smtpfrom = "email@domain.com"
smtpto = "email@domain.com"
smtpserver = "smtp.domain.com"

'create folders
m_cf = createFolderscopyFiles(user)
If m_cf <> 1 Then
	'update the registry and reboot
	m_ur = updateRegistry(user)
	If m_ur <> 1 Then
		'rename the old folders so it does not use them anymore!
		m_rof = renameOldFolders(user)
		'reboot
		Set WSHShell = WScript.CreateObject("WScript.Shell")
		WshShell.Run "C:\WINDOWS\system32\shutdown.exe -r -t 0"
	End If
End If

Function getUser()
	'get the current user environment variable.
	Set oShell = CreateObject( "WScript.Shell" )
	user = oShell.ExpandEnvironmentStrings("%UserName%")

	If Err.Number <> 0 Then
		'we have failure!
		getUser = 1
		Err.Clear
	Else
		getUser = user
	End If
End Function

Function createFolderscopyFiles(user)
	Set objFSO = CreateObject("Scripting.FileSystemObject")

	'lets only do the folder create and file copy if that folder doesn't already exist. Otherwise, its just gonna set the registry and reboot.
	If Not objFSO.FolderExists(serverpath & user & "\Desktop-" & user) Then
		'Create the new Desktop and the Favorites folder.
		objFSO.CreateFolder(serverpath & user & "\Desktop-" & user)
		objFSO.CreateFolder(serverpath & user & "\Favorites-" & user)

		Set oSHApp = CreateObject("Shell.Application")

		'Copy the Desktop files
		Set fromDFolder = oSHApp.Namespace("C:\Documents and Settings\" & user & "\Desktop")
		Set toDFolder = oSHApp.Namespace(serverpath & user & "\Desktop-" & user)
		toDFolder.CopyHere fromDFolder.Items, 16+512

		'Copy the Favorites files
		Set fromFFolder = oSHApp.Namespace("C:\Documents and Settings\" & user & "\Favorites")
		Set toFFolder = oSHApp.Namespace(serverpath & user & "\Favorites-" & user)
		toFFolder.CopyHere fromFFolder.Items, 16+512
	End If

	If Err.Number <> 0 Then
		'we have failure!
		SendEmail user,"failed at createFolderscopyFiles",Err.Description
		createFolderscopyFiles = 1
		Err.Clear
	Else
		createFolderscopyFiles = 0
	End If
End Function

Function updateRegistry(user)
	'lets work on the registry now
	Const HKEY_CURRENT_USER = &H80000001
	Const HKEY_LOCAL_MACHINE = &H80000002

	'update the registry for Desktop and Favorites (User Shell Folders)
	'set Favorites
	Set oFReg=GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & "." & "\root\default:StdRegProv")
	strKeyPath = "Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders"
	strValueName = "Favorites"
	strValue = serverpath & user & "\Favorites-" & user
	oFReg.SetExpandedStringValue HKEY_CURRENT_USER,strKeyPath,strValueName,strValue
	'set Desktop
	Set oDReg=GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & "." & "\root\default:StdRegProv")
	strKeyPath = "Software\Microsoft\Windows\CurrentVersion\Explorer\User Shell Folders"
	strValueName = "Desktop"
	strValue = serverpath & user & "\Desktop-" & user
	oDReg.SetExpandedStringValue HKEY_CURRENT_USER,strKeyPath,strValueName,strValue

	'update the registry for Desktop and Favorites (Shell Folders)
	'set Favorites
	Set otFReg=GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & "." & "\root\default:StdRegProv")
	strKeyPath = "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
	strValueName = "Favorites"
	strValue = serverpath & user & "\Favorites-" & user
	otFReg.SetStringValue HKEY_CURRENT_USER,strKeyPath,strValueName,strValue
	'set Desktop
	Set otDReg=GetObject("winmgmts:{impersonationLevel=impersonate}!\\" & "." & "\root\default:StdRegProv")
	strKeyPath = "Software\Microsoft\Windows\CurrentVersion\Explorer\Shell Folders"
	strValueName = "Desktop"
	strValue = serverpath & user & "\Desktop-" & user
	otDReg.SetStringValue HKEY_CURRENT_USER,strKeyPath,strValueName,strValue

	If Err.Number <> 0 Then
		'we have failure!
		SendEmail user,"failed at updating registry",Err.Description
		updateRegistry = 1
		Err.Clear
	Else
		updateRegistry = 0
	End If
End Function

Function renameOldFolders(user)
	Set objFSO = CreateObject("Scripting.FileSystemObject")
	objFSO.MoveFolder "C:\Documents and Settings\" & user & "\Desktop", "C:\Documents and Settings\" & user & "\DesktopOLD"
	objFSO.MoveFolder "C:\Documents and Settings\" & user & "\Favorites", "C:\Documents and Settings\" & user & "\FavoritesOLD"

	If Err.Number <> 0 Then
		'we have failure!
		SendEmail user,"failed at renaming old folders",Err.Description
		renameOldFolders = 1
		Err.Clear
	Else
		renameOldFolders = 0
	End If
End Function

Sub SendEmail(user,contnt,contntB)
	'if the setting is to send an email, then do it, otherwise...nada.
	If useemailnotify = 1 Then
		'send an email!!
		Set objEmail = CreateObject("CDO.Message")
		objEmail.From = smtpfrom
		objEmail.To = smtpto
		objEmail.Subject = "Desktop and Favorites Migration Issue for " & user
		objEmail.Textbody = "User had a Desktop files migration error." & vbCrLf & vbCrLf & contnt & vbCrLf & vbCrLf & contntB
		objEmail.Configuration.Fields.Item("http://schemas.microsoft.com/cdo/configuration/sendusing") = 2
		objEmail.Configuration.Fields.Item("http://schemas.microsoft.com/cdo/configuration/smtpserver") = smtpserver
		objEmail.Configuration.Fields.Item("http://schemas.microsoft.com/cdo/configuration/smtpserverport") = 25
		objEmail.Configuration.Fields.Update
		objEmail.Send

		If Err.Number <> 0 Then
			'we have failure!
			MsgBox "Your Desktop migration didn't go very well."
			Err.Clear
		Else
			'YAY!
		End If
	End If
End Sub

Downloads

BlankScreen.zip – VB.NET application

desktop.zip – VBScript

I already know what you are thinking…however, that does not eliminate the fact that dashboard reports are favored by CIOs, IT Directors and the like. Better have that score up to 100%!

StartupNotification

I wrote an application, StartupNotification, that helps with maintaining good scores. Keep in mind that this application only provides a means for notifying the appropriate personnel when a workstation is brought on the network that could potentially “damage”. Second, for this application to be effective in notifying, it must be added as a domain GPO or local policy startup script.

How It Works

Ran from a Windows computer startup script, StartupNotification checks a SQL database for previous records associated with the name of the workstation running StartupNotification. If no records exist, it reports an “Untracked” workstation; if record(s) exist and the latest record is (x) days old, it reports a “Tracked” workstation. After checking the status of the workstation, StartupNotification will create a new record with the workstation name and date of transaction, which will be used at the next StartupNotification check in.

The Application

Download source code (written in Visual Studio 2008).

If you are interested in this application working in your environment, then there are a few things your must do…

1. Create a SQL table with the necessary fields.
2. Update the application code with your connection string for the database.
3. Update the email notification messages.
4. Update the SMTP “from” email address.

This is simple, I’ll help you along the way if you follow the steps below carefully:

SQL Database and Table

I use Microsoft SQL Server 2005; however, this could be easily ported to MySQL, another SQL database, or even a Microsoft Access database. I created a separate database named STARTUPNOTIFICATION for the purpose of holding the table. The table layout is simple, as shown below:

createscript.sql

You must have a SQL user account that can SELECT and INSERT to this table. It is recommended that this account be a separate account and not the “sa” account or some other powerful, generic account.

Update Connection String

Locate the “mySQL.ConnectionString” property in the code, as shown the screen shot below, and update the string to match your server and database.

Update Email Notification Messages

Locate the “sendEmail” function calls, as shown in the screen shot below, and update the strings to display the text you want to be included in the email. As an example, I have another application I wrote that grabs information on the workstation and user at sign-in; I place a link to display who has signed in to that workstation in the email for quick identification of the workstation location.

Update SMTP “From” Address

The final line that needs your attention is the email address that is used as the sender for this application. In most cases you should use a “do not reply” type email address. Locate the sendEmail function near the bottom of the code and modify the msg.From property line, as shown the screen shot below.

That is all, compile and set to run as in a startup script. For GPO startup scripts, the application could reside in the NETLOGON path as permissions have not been granted by a signed in user.

Aaron Gilbert

And yes, the “screensaver” fade was included in the custom web browser as well. See my article on SteadyState and Screensavers for more information on why I decided to do it that way.

Although the custom web browser was written in Visual Studio .NET 2005 Professional, anyone with a Windows XP + computer could download the free Microsoft Visual Studio 2008 Express  products, such as VB.NET and create the .NET application described below.

New .NET Windows Application

Start out by creating a new .NET Windows Application in the language of your choice. For this example, I will use Visual Basic.

~

frmMain :: the Main Form

1. First we will modify the form, setting FormBorderStyle to None and setting WindowState to Maximized to fill the entire screen with no border.

2. Next lets drag a ToolStrip on the form, this will be used for navigation.

3. While you are dragging the ToolStrip object, drag two (2) Timer objects – we will use these later on.

4. Modify Timer1 to tick at 1000 millisecond intervals and Timer2 to tick at 180000 (3 minutes) intervals. Timer1 should be enabled and Timer2 disabled.

5. Now lets drag a WebBrowser component on to the form, this will be used for … well web browsing?

6. For minimal control, add just three buttons to the ToolStrip for controlling the WebBrowser: (1) Back; (2) Refresh; and (3) Back to devtrends.com. To make the buttons better looking than just text or the standard image, I’ve created custom bitmaps.

Modify the buttons, DisplayStyle to ImageAndText and Text to the text of the button.

On to the code…

1. Lets start by modifying the button actions, so double click on the Back button. Use the following code:

'tell the web browser to go back.
If WebBrowser1.CanGoBack = True Then
  WebBrowser1.GoBack()
End If

2. Refresh button:

'tell the web browser to refresh the page
WebBrowser1.Refresh()

3. back to devtrends.com button:

'tell the web browser to go to devtrends.com
WebBrowser1.Navigate("http://www.devtrends.com/")

4. Now lets modify the Load statement to contain the same code as the back to devtrends.com button. This way our web page loads first everytime.

5. Lets make sure the user cannot close the form/application by adding the following code to the FormClosing event for the form:

'prevent user from closing the application
If e.CloseReason = CloseReason.UserClosing Then
  e.Cancel = True
End If

6. Back at the top of the code, add the following variable statements:

Public mousex As Integer
Public mousey As Integer

7. In the Form Load statement, add the following statements:

mousex = MousePosition.X
mousey = MousePosition.Y

8. In Timer1 tick (double click on the Timer1 object in design view), add the following statements:

If mousex <> MousePosition.X Or mousey <> MousePosition.Y Then
  Timer2.Enabled = False
Else
  'the mouse has not moved... start Timer2
  Timer2.Enabled = True
End If

'set current mouse position.
mousex = MousePosition.X
mousey = MousePosition.Y

9. In Timer2 tick, add the following statements:

Dim fadeform As New frmFader
fadeform.Show()

~

subMain :: “sub main” Module

This may be an old school method, however, we’ll create a module that contains a Sub main. Sub main will be the starting point for your application, which we will modify as the last step in this section.

Right click on your project and choose Add > Module, and name the module subMain.

1. Add the following code to your newly created module:

'instantiate public form object of frmMain, which we will use to reference later on from frmFader
 Public mainfrm As New frmMain

 Sub Main()
   'display the main form.
   mainfrm.Show()

   'keep the application running...
   Application.Run()
 End Sub

2. Modify the Visual Studio Project Properties, uncheck “Use Application Framework” and choose Startup object, “Sub Main”.

~

frmFader :: “Screensaver” Fader Form

Lets create the next form, frmFader. Right click on your project and choose Add > Windows Form, and name the form frmFader. Immediate make the following design modifications to your new form:

1. Change WindowState to Maximized.

2. TopMost to True.

3. ShowInTaskbar to False.

4. FormBorderStyle to None.

5. BackColor to Black.

Next we’ll modify the code behind the frmFader form that will make the form 50% transparent or 0% transparent, depending on the time of day. Remember, I needed an application that would black the screen out during a certain time window.

1. At the top of the code, add the following statements, which will be used to watch if the mouse is moved:

Public mousex As Integer
Public mousey As Integer

2. In the Form Load sub, add the following code:

'stop Timer1 and Timer2 on frmMain
mainfrm.Timer1.Enabled = False
mainfrm.Timer2.Enabled = False

'set current mouse positions
mousex = MousePosition.X
mousey = MousePosition.Y

'hide the mouse cursor
Cursor.Hide()

'get the current hour
Dim curHour As Integer
curHour = Hour(Now())

'if the time is between 8am and 5pm then use 50% otherwise 100%
If curHour >= 8 And curHour <= 17 Then
  Me.Opacity = 0.5
Else
  Me.Opacity = 1
End If

The comment lines explain most of what the code is doing. However, in the beginning of the code, I have it stop the Timers on the calling form (frmMain). This is required otherwise you would get multiple “screensavers” appear every 3 minutes.

3. In the Form Closing sub, we must add the following code to ensure the screensaver will reappear (we did stop the timers and hid the mouse cursor, remember?):

mainfrm.Timer1.Enabled = True
Cursor.Show()

4. Finally, lets watch for mouse movement on the form as we want to close the form when the mouse is moved. In the Form Mousemove sub, add the following code:

If mousex <> MousePosition.X Or mousey <> MousePosition.Y Then
  'the mouse moved... lets close this overlayed form
  Me.Close()
End If

That’s it…I’m out. If you want to cheat, just download the source code below. And as always, use this stuff at your own risk.

Download the kiosk source code

As a recap, we are creating a custom workflow action that allows you to send an email with the attachments from a specified list in your site. The custom workflow action will allow you to configure four user input fields: (a) the Email Content; (b) the Send From Email; (c) the SMTP Host; and (d) the Associated List.

Although this project can be broken down into three sequential steps, these three steps are so closely intertwined that content from all three are required by the other three. With that stated, read all three sections, play around, then begin your actual development. The three steps are:

Step One: Create and Compile your .NET Workflow Activity
Step Two: Modify or Create .ACTIONS file and Add to Authorized Assemblies
Step Three: Deploy to WSS server and GAC

Step Three: Deploy to WSS server and GAC

This step assumes you successfully completed Part 1 of 3 and Part 2 of 3. This Part is considerably shorter than 1 and 2 because you will likely run through the steps in the Part many times as your debug your SharePoint Workflow action DLL.

Copy the Compiled Assembly DLL to WSS

Although some people recommend deploying your DLL to a specific folder under the Windows folder, I recommend for this project and other projects to deploy the DLL into the SharePoint folder structure. Therefore, we will deploy your DLL to the SharePoint folder: C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\ISAPI

Let’s copy the latest compile from your Visual Studio project as was in Part 1 of 3 to the SharePoint folder listed above.

Next, we will need to use the gacutil.exe tool to add the DLL to the GAC cache. Run the following commands from a command prompt at the location of the DLL:

C:\…\web server extensions\12\ISAPI>gacutil /I devtrends.EmailAttachments.dll

You should receive a message similar to: “Assembly successfully added to the cache”

If you received a bad command or filename error, then the gacutil.exe application may not be readily available to the command prompt. The gacutil.exe is a tool that is included with the .NET framework, specifically all .NET frameworks. Depending on the level of .NET framework you wrote the program in, you need that level or higher of the gacutil.exe application. For the purpose of this article, the gacutil.exe version is 3.5, and the gacutil.exe was copied to the C:\…\web server extensions\12\ISAPI folder. You may need to search your computer for the gacutil.exe and copy it to the SharePoint folder that you copied your compiled DLL.

Finally, you will need to restart your Information Information Server, so issue the command iisreset:

C:\…\web server extensions\12\ISAPI>iisreset

Open SharePoint Designer, you should now have the custom action in your list of Workflow actions.

I hope this article was helpful. If you have questions please submit them as a comment.

As a recap, we are creating a custom workflow action that allows you to send an email with the attachments from a specified list in your site. The custom workflow action will allow you to configure four user input fields: (a) the Email Content; (b) the Send From Email; (c) the SMTP Host; and (d) the Associated List.

Although this project can be broken down into three sequential steps, these three steps are so closely intertwined that content from all three are required by the other three. With that stated, read all three sections, play around, then begin your actual development. The three steps are:

Step One: Create and Compile your .NET Workflow Activity
Step Two: Modify or Create .ACTIONS file and Add to Authorized Assemblies
Step Three: Deploy to WSS server and GAC

Step Two: Modify or Create .ACTIONS file and Add to Authorized Assemblies

First we will sign our new assembly as was created in Part 1 of 3 of this article. The signing process is required as we will extract the public key token from the assembly to use in the .ACTIONS file and the authorized assemblies list.

Let’s begin by opening up the Visual Studio project we created in Part 1 of 3, so open Visual Studio 2008.

Signing Assembly

Once the project is open, click on Project and then the project Properties menu option.

First, in the project properties tab for informational purposes, look at the Assembly name and the Default namespace; these should be the same as your class and the name of your project when you created the project.

Click on the Signing side-tab, check the box to Sign the assembly and then select the dropdown list and choose <New…>.

In the Create Strong Name Key window, type in the Key file name, using the same name as your project and class, uncheck Protect my key file with a password, and then click OK.

Your project should now be signed, as shown below:

Acquiring the Public Key Token

Hopefully by now your code from Part 1 of 3 compiles successfully. If not, you must first fix and successfully compile your code. After your code is compiled, you will need to acquire the public key token from the compiled code. This process is done through using the Strong Name Tool (sn.exe) application that comes with the Visual Studio environment.

http://msdn.microsoft.com/en-us/library/k5b5tt23(VS.80).aspx

To simplify acquiring the public key token, we can add this application as an external tool in the Visual Studio environment. Click on Tools and then External Tools…

Add a new External tool, name the title Display Public Key Token, with command: C:\Program Files\Microsoft SDKs\Windows\v6.0A\bin\sn.exe, and arguments: -Tp “$(TargetPath)”. Click OK.

Note: For those with Visual Studio 2005, the sn.exe tool is not located in the location as specified in this article. Search for sn.exe on your computer to determine the location.

Click on Tools again, and this time choose Display Public Key Token from the menu. The Output window should display and the token will be listed in the contents of that window:

Remember the public key token as you will use it twice during the rest of this Part 2 of 3.

Modify or Create .ACTIONS file

The .ACTIONS file defines how the Workflow action will be displayed SharePoint Designer 2007. The .ACTIONS file also defines how data is transformed to the Workflow code as created in Part 1 of 3.

Although this goes against standard procedure, we are going to add the actions configuration to the existing WSS.ACTIONS file. Be sure to back up the current WSS.ACTIONS file prior to editing.

Open WSS.ACTIONS in your favorite text editor and scroll to the bottom of the text document. Find the last </Action> closing tag (“Action”, singular not plural) and paste the follow code immediately following the closing action tag:

<Action Name=”Email List Attachments”

ClassName=”devtrends.EmailAttachments.SendEmailwithListAttachments”

Assembly=” devtrends.EmailAttachments, Version=1.0.0.0, Culture=neutral, PublicKeyToken=977438f55cbfd7aa”

AppliesTo=”all”

Category=”devtrends”>

<RuleDesigner Sentence=”Send %1 from %2 via SMTP host %3. Send attachments from list %4.”>

<FieldBind Field=”To,CC,Subject,Body” Text=”this message” DesignerType=”Email” Id=”1″/>

<FieldBind Field=”FromUser” Text=”this user” Id=”2″ DesignerType=”TextArea”/>

<FieldBind Field=”SMTPServerName” Text=”SMTP Server” Id=”3″ DesignerType=”TextArea”/>

<FieldBind Field=”ListId,ListItem” Text=”this list” Id=”4″ DesignerType=”ChooseListItem”/>

</RuleDesigner>

<Parameters>

<Parameter Name=”To” Type=”System.Collections.ArrayList, mscorlib” Direction=”In” />

<Parameter Name=”CC” Type=”System.Collections.ArrayList, mscorlib” Direction=”Optional” />

<Parameter Name=”Subject” Type=”System.String, mscorlib” Direction=”In” />

<Parameter Name=”Body” Type=”System.String, mscorlib” Direction=”Optional” />

<Parameter Name=”FromUser” Type=”System.String, mscorlib” Direction=”In” />

<Parameter Name=”SMTPServerName” Type=”System.String, mscorlib” Direction=”In” InitialValue=”127.0.0.1″ />

<Parameter Name=”__Context” Type=”Microsoft.SharePoint.WorkflowActions.WorkflowContext, Microsoft.SharePoint.WorkflowActions” Direction=”In”/>

<Parameter Name=”ListId” Type=”System.String, mscorlib” Direction=”In” />

<Parameter Name=”ListItem” Type=”System.Int32, mscorlib” Direction=”In” />

</Parameters>

</Action>

Replace the public key token value in the first line with the public key token you acquired from earlier in this Part 2 of 3. Save the WSS.ACTIONS file.

Authorize the Assembly

In this step we will add our new assembly to the authorized assembly list. This list is stored in the web.config file for your SharePoint Services installation. The standard location for this file will be: C:\Inetpub\wwwroot\wss\VirtualDirectories\80\

Open the web.config file using your favorite text editor and scroll to the bottom of the web.config file. In the System.Workflow.ComponentModel.WorkflowCompiler, authorizedTypes section add the follow line:

<authorizedType Assembly=”devtrends.EmailAttachments, Version=1.0.0.0, Culture=neutral, PublicKeyToken=977438f55cbfd7aa” Namespace=”devtrends.EmailAttachments” TypeName=”*” Authorized=”True” />

Be sure to change the PublicKeyToken field to match the public key token as was acquired earlier in this Part 2 of 3.

Save the web.config file.

Please continue to Custom Workflow Actions (Part 3 of 3)

What I did not realize was that the workflow actions in SharePoint Designer are quite basic. I had built up in my mind that the workflow capabilities of SharePoint were powerful from what I heard from so many individuals. What I did not realize was, while the fact that SharePoint workflows are powerful, to make them perform unique tasks it would require considerable involvement.

Unfortunately for me, I had a deadline to complete the task within two days. Thus began the conquering of creating a custom workflow action. Since much of the information I found on the Internet seemed to be missing pieces of the puzzle, here is my attempt to create a complete tutorial on creating a custom workflow action in Visual Studio 2008 that is applicable in SharePoint Designer and Windows SharePoint Services.

Requirements

Microsoft SharePoint Designer 2007, Microsoft Visual Studio 2008, Microsoft Windows SharePoint Services, and patience.

If programming for SharePoint is new to you, patience will serve you well. I was very frustrated for the two days while I figured out and then produced what I am going to explain to you below.

Fundamentals

The workflow functionality of SharePoint is based on the Windows Workflow Foundations (WWF) programming model, therefore if you have experience with WWF you may find programming workflow actions for SharePoint intuitive. Microsoft Windows SharePoint Services (WSS) is built on .NET Framework technology, which we will be utilizing for the workflow action program. If you understand both of these technologies well, creating a custom workflow action will be a breeze.

Creating a Custom Workflow Action

Enough with the preliminary text, let’s get started with creating the custom workflow action.

For the demonstration, we will be creating a custom workflow action that allows you to send an email with the attachments from a specified list in your site. The custom workflow action will allow you to configure four user input fields: (a) the Email Content; (b) the Send From Email; (c) the SMTP Host; and (d) the Associated List.

Although this project can be broken down into three sequential steps, these three steps are so closely intertwined that content from all three are required by the other three. With that stated, read all three steps, play around, then begin your actual development. The three steps are:

Step One: Create and Compile your .NET Workflow Activity
Step Two: Modify or Create .ACTIONS file and Add to Authorized Assemblies
Step Three: Deploy to WSS server and GAC

Step One: Create and Compile your .NET Workflow Activity

Project Environment Setup

Let’s begin by setting up the Visual Studio project and the environment, so open Visual Studio 2008.

In Visual Studio 2008, start a new Project by clicking on File > New Project.

In the New Project window, choose Workflow Activity Library and name the activity the same name you will use for the rest of the project. For the purposes of this demonstration, we will name the project devtrends.EmailAttachments. Click OK.

Since a custom workflow action does not have any graphical interface and in addition we are creating a single workflow activity, go ahead and immediately view the code for the project.

Next, we will add the references to two DLLs that are associated with the installation of Windows SharePoint Services (WSS). These files will reside on the server that runs WSS, which is likely in the path: \\server_name\c$\Program Files\Common Files\Microsoft Shared\web server extensions\12\ISAPI\

Copy the files:

Microsoft.SharePoint.dll
Microsoft.SharePoint.xml
Microsoft.sharepoint.WorkflowActions.dll
Microsoft.sharepoint.WorkflowActions.xml

to your local computer, using the destination location, C:\Program Files\Common Files\Microsoft Shared\web server extensions\12\ISAPI\.

Now that those files are copied to your local development computer, return to the Visual Studio project and add these two DLLs as references.

Now, add a few “using” statements to include the required namespaces. The namespace list for this project is as shown below, with the additional statements added at the end of the “using” line up.

Just two more changes, as shown as below: (a) change the name of the partial class to “SentEmailwithListAttachments” by modifying the first line to be (ensure that you are not editing the Designer.cs file); and (b) Add the five Using statements, Microsoft.SharePoint, Microsoft.SharePoint.Workflow, Microsoft.SharePoint.WorkflowActions, System.Net.Mail and System.IO.

Now that we are ready to create the SharePoint Workflow Activity, let’s begin by copying and pasting the following code into your partial class, SendEmailwithListAttachments:

#region DepedencyProperties for the Activity

public static DependencyProperty BCCProperty = DependencyProperty.Register(“BCC”, typeof(ArrayList), typeof(SentEmailwithListAttachments));

public static DependencyProperty BodyProperty = DependencyProperty.Register(“Body”, typeof(string), typeof(SentEmailwithListAttachments));

public static DependencyProperty CCProperty = DependencyProperty.Register(“CC”, typeof(ArrayList), typeof(SentEmailwithListAttachments));

public static DependencyProperty SubjectProperty = DependencyProperty.Register(“Subject”, typeof(string), typeof(SentEmailwithListAttachments));

public static DependencyProperty ToProperty = DependencyProperty.Register(“To”, typeof(ArrayList), typeof(SentEmailwithListAttachments));

public static DependencyProperty FromUserProperty = DependencyProperty.Register(“FromUser”, typeof(string), typeof(SentEmailwithListAttachments));

public static DependencyProperty SMTPServerNameProperty = DependencyProperty.Register(“SMTPServerName”, typeof(string), typeof(SentEmailwithListAttachments));

public static DependencyProperty __ContextProperty = DependencyProperty.Register(“__Context”, typeof(WorkflowContext), typeof(SentEmailwithListAttachments));

public static DependencyProperty ListIdProperty = DependencyProperty.Register(“ListId”, typeof(string), typeof(SentEmailwithListAttachments));

public static DependencyProperty ListItemProperty = DependencyProperty.Register(“ListItem”, typeof(int), typeof(SentEmailwithListAttachments));

#endregion

#region Properties

[ValidationOption(ValidationOption.Required)]

public WorkflowContext __Context

{

get

{

return (WorkflowContext)(base.GetValue(__ContextProperty));

}

set

{

base.SetValue(SentEmailwithListAttachments.__ContextProperty, value);

}

}

[ValidationOption(ValidationOption.Required)]

public string ListId

{

get

{

return (string)(base.GetValue(ListIdProperty));

}

set

{

base.SetValue(SentEmailwithListAttachments.ListIdProperty, value);

}

}

[ValidationOption(ValidationOption.Required)]

public int ListItem

{

get

{

return (int)(base.GetValue(ListItemProperty));

}

set

{

base.SetValue(SentEmailwithListAttachments.ListItemProperty, value);

}

}

[ValidationOption(ValidationOption.Required)]

public string FromUser

{

get

{

return (string)base.GetValue(FromUserProperty);

}

set

{

base.SetValue(FromUserProperty, value);

}

}

[ValidationOption(ValidationOption.Required)]

public string SMTPServerName

{

get

{

return (string)base.GetValue(SMTPServerNameProperty);

}

set

{

base.SetValue(SMTPServerNameProperty, value);

}

}

[ValidationOption(ValidationOption.Optional)]

public string Body

{

get

{

return (string)base.GetValue(BodyProperty);

}

set

{

base.SetValue(BodyProperty, value);

}

}

[ValidationOption(ValidationOption.Optional)]

public ArrayList CC

{

get

{

return (ArrayList)base.GetValue(CCProperty);

}

set

{

base.SetValue(CCProperty, value);

}

}

[ValidationOption(ValidationOption.Required)]

public string Subject

{

get

{

return (string)base.GetValue(SubjectProperty);

}

set

{

base.SetValue(SubjectProperty, value);

}

}

[ValidationOption(ValidationOption.Required)]

public ArrayList To

{

get

{

return (ArrayList)base.GetValue(ToProperty);

}

set

{

base.SetValue(ToProperty, value);

}

}

#endregion

#region Initialization

public SentEmailwithListAttachments()

{

InitializeComponent();

}

#endregion

#region Overidden Method (ActivityExecutionStatus)

protected override ActivityExecutionStatus Execute(ActivityExecutionContext executionContext)

{

try

{

//Send the email

//grab the Activity for the Lookup Fields to be based on

Activity myActivity = executionContext.Activity;

while (myActivity.Parent != null)

{

myActivity = myActivity.Parent;

}

//Send the email with attachments!!

SendEmail(myActivity);

}

finally

{

//nada

}

//Indicate the activity has closed

return ActivityExecutionStatus.Closed;

}

#endregion

#region SendEMail

private void SendEmail(Activity parent)

{

//STEP 1: Create a new object that will send the email

System.Net.Mail.MailMessage msg = new System.Net.Mail.MailMessage();

//STEP 2: Create the fromAddress variable and then determine the from email address

//Create an object to specify the from address for the email

System.Net.Mail.MailAddress fromAddress;

try

{

//set the email address

fromAddress = new System.Net.Mail.MailAddress(FromUser);

}

catch (System.Exception Ex)

{

fromAddress = new System.Net.Mail.MailAddress(“no-reply@domain.com”);

}

//Set the from email address on the message object

msg.From = fromAddress;

//STEP 3: Determine who the email will be sent to, To and CC, and add those email addresses to the msg object created in STEP 1.

try

{

//Add the email addresses stored in the To property to the email message object

for (int i = 0; i < To.Count; i++)

{

msg.To.Add(To[i].ToString());

}

}

catch (System.Exception Ex)

{

//errored out on the To list

msg.To.Add(“administrator@domain.com”);

}

try

{

//Add the email addresses stored in the CC property to the email message object

if (CC != null)

{

for (int i = 0; i < CC.Count; i++)

{

msg.CC.Add(CC[i].ToString());

}

}

}

catch (System.Exception Ex)

{

//errored out on the CC list… odd

msg.CC.Add(“administrator@domain.com”);

}

//STEP 4: Create the subject line for this Email

String mySubject = “”;

try

{

//To include fields in the subject line from the List, uncomment the lines below

//mySubject += Subject;

//mySubject += ” (” + Helper.LookupString(this.__Context, this.ListId, this.ListItem, “My Field 1″) + “)”;

mySubject = Subject;

}

catch (System.Exception Ex)

{

mySubject = “ERR: Invalid Subject Line”;

}

msg.Subject = mySubject;

//STEP 5: Generate the message body

//start the handling of the message body.

msg.IsBodyHtml = true;

String myBody = Body;

//make SharePoint replace the Lookup Strings in the field

try

{

//process the Add Lookup strings [%...%] from the Workflow configuration

myBody = Helper.ProcessStringField(myBody, parent, this.__Context);

}

catch (System.Exception Ex)

{

//nothing, couldn’t process strings for some reason.

}

msg.Body = myBody;

//STEP 6: Add the file attachments as added on the list

//begin file attachments…

//set current Site information and List

try

{

//create a hierarchy of objects starting from the base SharePoint web to the List Item’s attachment collection

SPWeb spWeb = (SPWeb)(__Context.Web);

SPSite Site = (SPSite)(__Context.Site);

SPList List = spWeb.Lists[new Guid(this.ListId)];

SPListItem ListItem = List.GetItemById(this.ListItem);

//get file information from the list item attachment URL address

SPFolder spFolder = spWeb.GetFolder(ListItem.Attachments.UrlPrefix);

//iterate all files in List Item (SPFileCollection)

SPFileCollection ColOfFiles = spFolder.Files;

foreach (SPFile spFile in ColOfFiles)

{

//open a binary stream to transfer to the email message

string strFileName = spFile.Name;

System.IO.Stream binFile = spFile.OpenBinaryStream();

//If needed, add the filename to the message body also.

//msg.Body += strFileName;

//add file to email message through binary stream

msg.Attachments.Add(new Attachment(binFile, strFileName));

}

}

catch (System.Exception ex)

{

//file attachment failed.

msg.Body += “ERR: Attempted to add files: “ + ex.Message + ex.StackTrace;

}

//STEP 7: Create an object to represent the mail server and SEND the message

System.Net.Mail.SmtpClient client = new System.Net.Mail.SmtpClient(SMTPServerName);

//Set the credentials used to authenticate to the email server

client.UseDefaultCredentials = true;

//Send the message

client.Send(msg);

//Use the follow Catch with a Try statement to write specific errors to a local disk file for debugging issues. (Requires System.IO)

//}

//catch (System.Exception Ex)

//{

// create a writer and open the file

// TextWriter tw = new StreamWriter(“c:\\error.log”);

// write a line of text to the file

// tw.WriteLine(DateTime.Now + ” – ” + Ex.Message + Ex.StackTrace);

// close the stream

// tw.Close();

//}

}

#endregion

Compile the code; you will hopefully receive a Build Succeeded.

Please continue to Custom Workflow Actions (Part 2 of 3)