Are there techniques for dynamic analysis of shared libraries? I know for example that DLLs have an entry point, but how about calling other exported functions? Do I need to write a custom executable that calls exports for each DLL I want to analyze?
A dynamically linked library has the same executable header and structure as a standard executable. Therefore they can be debugged the same way that a normal executable can be debugged. It might be a bit tricker than usual, because in order to debug it, it has to be loaded into some process, and making that happen could be trivial (i.e. if it's loaded as part of some other program) or it might take some doing.
A common technique is to use something like OllyDbg's LoadDll. The linked page describes a few examples of calling exports within the DLL directly. Although OllyDbg has some smarts to determine the number of function arguments, it's likely that you will have to do some reverse engineering to figure out what the types of those arguments should be. See this recent question for some advice on how to go about doing that.
Alternative, you can write a small program to load the DLL and call interesting exports manually. This is still subject to the limitations of needing to know how to interface with the DLL, but at the same time, this programming route might prove necessary in order to thoroughly reverse engineer your target. I.e., perhaps you need to call some export in order to create some object that the program is expecting as input for another export. LoadDll will quickly prove cumbersome, and writing this program really ought not to be that difficult.
Another method might be using IDA's AppCall feature: After defining a prototype for the relevant exported functions in IDA, you could trigger the function's execution from the IDA console menu in the currently running process's context.
you can more about how this feature works and how to use it in the hexblog relevant post: http://www.hexblog.com/?p=113.
DynamoRIO could be very good for more in-depth dynamic library analysis. DynamoRIO is a dynamic binary translator that works on both Linux and Windows, for both x86 and x86-64.
To analyse DLLs using DynamoRIO, you would register module load and unload events using the
dr_register_module_unload_event functions, respectively.
You can also register events that allow you to manipulate instructions before they are executed. These events would enable you to isolate code that is executed from a particular DLL, and apply custom instrumentation to that DLL.
The first naive idea would be to list the symbols of the functions and use it as entrypoints to the binary to disassemble each function.
Then, if you are looking for more advanced techniques, you should take a look at the IDA FLIRT signatures. There have been a question about it here, I recommend you to take a look at the answers: What is a FLIRT signature?